home *** CD-ROM | disk | FTP | other *** search
/ Linux Cubed Series 7: Sunsite / Linux Cubed Series 7 - Sunsite Vol 1.iso / system / network / samba / patches / samba-1.014 / samba-1
Encoding:
Text File  |  1995-07-01  |  70.4 KB  |  2,458 lines
  1. diff -u -r --new-file last-version/examples/tridge/README samba-1.9.14alpha4/examples/tridge/README
  2. --- last-version/examples/tridge/README    Thu Jun 29 16:42:40 1995
  3. +++ samba-1.9.14alpha4/examples/tridge/README    Sat Jul  1 13:23:17 1995
  4. @@ -1,4 +1,8 @@
  5.  This is the configuration I use at home. I have 2 client PCs, one
  6. -running Win95, one running alternately WfWg and NTAS3.5.
  7. +running Win95, one running alternately WfWg and NTAS3.5. My server is
  8. +a 486dx2-66 Linux box.
  9.  
  10. -My server is a 486dx266 Linux box.
  11. +Note that I use the %a and %m macros to load smb.conf extensions
  12. +particular to machines and architectures. This gives me a lot of
  13. +flexibility in how I handle each of the machines.
  14. +
  15. diff -u -r --new-file last-version/source/change-log samba-1.9.14alpha4/source/change-log
  16. --- last-version/source/change-log    Sat Jul  1 01:12:19 1995
  17. +++ samba-1.9.14alpha4/source/change-log    Sat Jul  1 15:05:38 1995
  18. @@ -1471,6 +1471,10 @@
  19.      - aix qconfig parsing from Jean-Pierre.Boulard@univ-rennes1.fr
  20.      - more long_date fixups
  21.      - added wildcards to nmbd
  22. +    - extensive changes to ipc.c and miscellaneous other changes 
  23. +    from ad@papyrus.hamburg.com (Andreas Degert). Should especially
  24. +    help OS/2 users
  25. +    
  26.  
  27.  ==========
  28.  todo:
  29. diff -u -r --new-file last-version/source/ipc.c samba-1.9.14alpha4/source/ipc.c
  30. --- last-version/source/ipc.c    Thu Jun 29 18:18:16 1995
  31. +++ samba-1.9.14alpha4/source/ipc.c    Sat Jul  1 14:58:44 1995
  32. @@ -17,11 +17,11 @@
  33.     You should have received a copy of the GNU General Public License
  34.     along with this program; if not, write to the Free Software
  35.     Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  36. -*/
  37. +   */
  38.  /*
  39.     This file handles the named pipe and mailslot calls
  40.     in the SMBtrans protocol
  41. -*/
  42. +   */
  43.  
  44.  
  45.  #include "includes.h"
  46. @@ -33,6 +33,7 @@
  47.  extern files_struct Files[];
  48.  
  49.  extern fstring local_machine;
  50. +extern BOOL lpq_cache_reset;
  51.  
  52.  #define NERR_Success 0
  53.  #define NERR_badpass 86
  54. @@ -40,14 +41,74 @@
  55.  
  56.  #define NERR_BASE (2100)
  57.  #define NERR_BufTooSmall (NERR_BASE+23)
  58. +#define NERR_JobNotFound (NERR_BASE+51)
  59. +#define NERR_DestNotFound (NERR_BASE+52)
  60. +#define ERROR_INVALID_LEVEL 124
  61. +#define ERROR_MORE_DATA 234
  62. +
  63. +#define REALLOC(ptr,size) Realloc(ptr,MAX((size),4*1024))
  64. +
  65. +#define ACCESS_READ 0x01
  66. +#define ACCESS_WRITE 0x02
  67. +#define ACCESS_CREATE 0x04
  68. +
  69. +#define STYPE_DISKTREE    0    /* Disk drive */
  70. +#define STYPE_PRINTQ    1    /* Spooler queue */
  71. +#define STYPE_DEVICE    2    /* Serial device */
  72. +#define STYPE_IPC    3    /* Interprocess communication (IPC) */
  73. +
  74. +#define SHPWLEN 8        /* share password length */
  75. +#define NNLEN 12        /* 8.3 net name length */
  76. +#define SNLEN 15        /* service name length */
  77. +#define QNLEN 12        /* queue name maximum length */
  78.  
  79. -#define REALLOC(ptr,size) Realloc(ptr,MAX((size),1024))
  80. +static int CopyExpanded(int cnum, int snum, char** dst, char* src, int* n)
  81. +{
  82. +  pstring buf;
  83. +  int l;
  84. +  strcpy(buf,src);
  85. +  string_sub(buf,"%S",lp_servicename(snum));
  86. +  standard_sub(cnum,buf);
  87. +  StrnCpy(*dst,buf,*n);
  88. +  l = strlen(*dst) + 1;
  89. +  *dst += l;
  90. +  *n -= l;
  91. +  return l;
  92. +}
  93. +
  94. +static int CopyAndAdvance(char** dst, char* src, int* n)
  95. +{
  96. +  int l;
  97. +  StrnCpy(*dst,src,*n);
  98. +  l = strlen(*dst) + 1;
  99. +  *dst += l;
  100. +  *n -= l;
  101. +  return l;
  102. +}
  103. +
  104. +static int StrlenExpanded(int cnum, int snum, char* s)
  105. +{
  106. +  pstring buf;
  107. +  strcpy(buf,s);
  108. +  string_sub(buf,"%S",lp_servicename(snum));
  109. +  standard_sub(cnum,buf);
  110. +  return strlen(buf) + 1;
  111. +}
  112. +
  113. +static char* Expand(int cnum, int snum, char* s)
  114. +{
  115. +  static pstring buf;
  116. +  strcpy(buf,s);
  117. +  string_sub(buf,"%S",lp_servicename(snum));
  118. +  standard_sub(cnum,buf);
  119. +  return buf;
  120. +}
  121.  
  122.  /****************************************************************************
  123. -send a trans reply
  124. -****************************************************************************/
  125. +  send a trans reply
  126. +  ****************************************************************************/
  127.  static void send_trans_reply(char *outbuf,char *data,char *param,uint16 *setup,
  128. -              int ldata,int lparam,int lsetup)
  129. +                 int ldata,int lparam,int lsetup)
  130.  {
  131.    int i;
  132.    int this_ldata,this_lparam;
  133. @@ -115,295 +176,693 @@
  134.  
  135.  
  136.  /****************************************************************************
  137. -get a print queue
  138. -Normal form: (uLevel=2) <zWrLh> <B13BWWWzzzzzWN> 
  139. -Alternate (uLevel=0): <zWrLh> <B13> 
  140. -****************************************************************************/
  141. +  get a print queue
  142. +  ****************************************************************************/
  143. +
  144. +struct pack_desc {
  145. +  char* format;            /* formatstring for structure */
  146. +  char* subformat;        /* subformat for structure */
  147. +  char* base;            /* baseaddress of buffer */
  148. +  int buflen;            /* remaining size for fixed part; on init: length of base */
  149. +  int subcount;            /* count of substructures */
  150. +  char* structbuf;        /* pointer into buffer for remaining fixed part */
  151. +  int stringlen;        /* remaining size for variable part */        
  152. +  char* stringbuf;        /* pointer into buffer for remaining variable part */
  153. +  int neededlen;        /* total needed size */
  154. +  int usedlen;            /* total used size (usedlen <= neededlen and usedlen <= buflen) */
  155. +  char* curpos;            /* current position; pointer into format or subformat */
  156. +  int errcode;
  157. +};
  158. +
  159. +static int get_counter(char** p)
  160. +{
  161. +  int i, n;
  162. +  if (!isdigit(**p)) return 1;
  163. +  for (n = 0;;) {
  164. +    i = **p;
  165. +    if (isdigit(i))
  166. +      n = 10 * n + (i - '0');
  167. +    else
  168. +      return n;
  169. +    (*p)++;
  170. +  }
  171. +}
  172. +
  173. +static int getlen(char* p)
  174. +{
  175. +  int n = 0;
  176. +  while (*p) {
  177. +    switch( *p++ ) {
  178. +    case 'W':            /* word (2 byte) */
  179. +      n += 2;
  180. +      break;
  181. +    case 'N':            /* count of substructures (word) at end */
  182. +      n += 2;
  183. +      break;
  184. +    case 'D':            /* double word (4 byte) */
  185. +    case 'z':            /* offset to zero terminated string (4 byte) */
  186. +    case 'l':            /* offset to user data (4 byte) */
  187. +      n += 4;
  188. +      break;
  189. +    case 'b':            /* offset to data (with counter) (4 byte) */
  190. +      n += 4;
  191. +      get_counter(&p);
  192. +      break;
  193. +    case 'B':            /* byte (with optional counter) */
  194. +      n += get_counter(&p);
  195. +      break;
  196. +    }
  197. +  }
  198. +  return n;
  199. +}
  200. +
  201. +static void init_package(struct pack_desc* p, int count, int subcount)
  202. +{
  203. +  int n = p->buflen;
  204. +  int i = count * getlen(p->format);
  205. +  if (p->subformat) i += subcount * getlen(p->subformat);
  206. +  p->structbuf = p->base;
  207. +  p->neededlen = 0;
  208. +  p->usedlen = 0;
  209. +  p->subcount = 0;
  210. +  p->curpos = p->format;
  211. +  if (i > n) {
  212. +    i = n = 0;
  213. +    p->errcode = NERR_BufTooSmall;
  214. +  }
  215. +  else
  216. +    p->errcode = NERR_Success;
  217. +  p->buflen = i;
  218. +  n -= i;
  219. +  p->stringbuf = p->base + i;
  220. +  p->stringlen = n;
  221. +}
  222. +
  223. +static int package(struct pack_desc* p, ...)
  224. +{
  225. +  va_list args;
  226. +  int needed=0, stringneeded;
  227. +  char* str=NULL;
  228. +  int is_string=0, stringused;
  229. +  va_start(args,p);
  230. +  if (!*p->curpos) {
  231. +    if (!p->subcount)
  232. +      p->curpos = p->format;
  233. +    else {
  234. +      p->curpos = p->subformat;
  235. +      p->subcount--;
  236. +    }
  237. +  }
  238. + #if CHECK_TYPES
  239. +  str = va_arg(args,char*);
  240. +  if (strncmp(str,p->curpos,strlen(str)) != 0) {
  241. +    DEBUG(2,("type error in package: %s instead of %*s in %s/%s\n",str,
  242. +          strlen(str),p->curpos,p->format1,p->format2));
  243. +    return 0;
  244. +  }
  245. + #endif
  246. +  stringneeded = -1;
  247. +  switch( *p->curpos++ ) {
  248. +  case 'W':            /* word (2 byte) */
  249. +    needed = 2;
  250. +    if (p->buflen >= needed) SSVAL(p->structbuf,0,va_arg(args,int16));
  251. +    break;
  252. +  case 'N':            /* count of substructures (word) at end */
  253. +    needed = 2;
  254. +    p->subcount = va_arg(args,int16);
  255. +    if (p->buflen >= needed) SSVAL(p->structbuf,0,p->subcount);
  256. +    break;
  257. +  case 'D':            /* double word (4 byte) */
  258. +    needed = 4;
  259. +    if (p->buflen >= needed) SIVAL(p->structbuf,0,va_arg(args,int32));
  260. +    break;
  261. +  case 'B':            /* byte (with optional counter) */
  262. +    needed = get_counter(&p->curpos);
  263. +    if (p->buflen >= needed) StrnCpy(p->structbuf,va_arg(args,char*),needed);
  264. +    break;
  265. +  case 'z':            /* offset to zero terminated string (4 byte) */
  266. +    str = va_arg(args,char*);
  267. +    stringneeded = (str ? strlen(str)+1 : 0);
  268. +    is_string = 1;
  269. +    break;
  270. +  case 'l':            /* offset to user data (4 byte) */
  271. +    str = va_arg(args,char*);
  272. +    stringneeded = va_arg(args,int);
  273. +    is_string = 0;
  274. +    break;
  275. +  case 'b':            /* offset to data (with counter) (4 byte) */
  276. +    str = va_arg(args,char*);
  277. +    stringneeded = get_counter(&p->curpos);
  278. +    is_string = 0;
  279. +    break;
  280. +  }
  281. +  va_end(args);
  282. +  if (stringneeded >= 0) {
  283. +    needed = 4;
  284. +    if (p->buflen >= needed) {
  285. +      stringused = stringneeded;
  286. +      if (stringused > p->stringlen) {
  287. +    stringused = (is_string ? p->stringlen : 0);
  288. +    if (p->errcode == NERR_Success) p->errcode = ERROR_MORE_DATA;
  289. +      }
  290. +      if (!stringused)
  291. +    SIVAL(p->structbuf,0,0);
  292. +      else {
  293. +    SIVAL(p->structbuf,0,PTR_DIFF(p->stringbuf,p->base));
  294. +    memcpy(p->stringbuf,str,stringused);
  295. +    if (is_string) p->stringbuf[stringused-1] = '\0';
  296. +    p->stringbuf += stringused;
  297. +    p->stringlen -= stringused;
  298. +    p->usedlen += stringused;
  299. +      }
  300. +    }
  301. +    p->neededlen += stringneeded;
  302. +  }
  303. +  p->neededlen += needed;
  304. +  if (p->buflen >= needed) {
  305. +    p->structbuf += needed;
  306. +    p->buflen -= needed;
  307. +    p->usedlen += needed;
  308. +  }
  309. +  else {
  310. +    if (p->errcode == NERR_Success) p->errcode = NERR_BufTooSmall;
  311. +  }
  312. +  return 1;
  313. +}
  314. +
  315. +#if CHECK_TYPES
  316. +#define PACK(desc,t,v) package(desc,t,v)
  317. +#define PACKl(desc,t,v,l) package(desc,t,v,l)
  318. +#else
  319. +#define PACK(desc,t,v) package(desc,v)
  320. +#define PACKl(desc,t,v,l) package(desc,v,l)
  321. +#endif
  322. +
  323. +static void PackDriverData(struct pack_desc* desc)
  324. +{
  325. +  char drivdata[4+4+32];
  326. +  SIVAL(drivdata,0,sizeof drivdata); /* cb */
  327. +  SIVAL(drivdata,4,1000);    /* lVersion */
  328. +  memset(drivdata+8,0,32);    /* szDeviceName */
  329. +  strcpy(drivdata+8,"IBMNULL");
  330. +  PACKl(desc,"l",drivdata,sizeof drivdata); /* pDriverData */
  331. +}
  332. +
  333. +static int check_printq_info(struct pack_desc* desc,
  334. +                  int uLevel, const char* id1, const char* id2)
  335. +{
  336. +  desc->subformat = NULL;
  337. +  switch( uLevel ) {
  338. +  case 0:
  339. +    desc->format = "B13";
  340. +    break;
  341. +  case 1:
  342. +    desc->format = "B13BWWWzzzzzWW";
  343. +    break;
  344. +  case 2:
  345. +    desc->format = "B13BWWWzzzzzWN";
  346. +    desc->subformat = "WB21BB16B10zWWzDDz";
  347. +    break;
  348. +  case 3:
  349. +    desc->format = "zWWWWzzzzWWzzl";
  350. +    break;
  351. +  case 4:
  352. +    desc->format = "zWWWWzzzzWNzzl";
  353. +    desc->subformat = "WWzWWDDzz";
  354. +    break;
  355. +  case 5:
  356. +    desc->format = "z";
  357. +    break;
  358. +  default: return False;
  359. +  }
  360. +  if (strcmp(desc->format,id1) != 0) return False;
  361. +  if (desc->subformat && strcmp(desc->subformat,id2) != 0) return False;
  362. +  return True;
  363. +}
  364. +
  365. +static void fill_printjob_info(int cnum, int snum, int uLevel,
  366. +                   struct pack_desc* desc,
  367. +                   print_queue_struct* queue, int n)
  368. +{
  369. +  PACK(desc,"W",((snum%0xFF)<<8) | (queue->job%0xFF)); /* uJobId */
  370. +  if (uLevel == 1) {
  371. +    PACK(desc,"B21",queue->user); /* szUserName */
  372. +    PACK(desc,"B",0);        /* pad */
  373. +    PACK(desc,"B16","");    /* szNotifyName */
  374. +    PACK(desc,"B10","PM_Q_RAW"); /* szDataType */
  375. +    PACK(desc,"z","");        /* pszParms */
  376. +    PACK(desc,"W",n+1);        /* uPosition */
  377. +    PACK(desc,"W",queue->status); /* fsStatus */
  378. +    PACK(desc,"z","");        /* pszStatus */
  379. +    PACK(desc,"D",queue->time); /* ulSubmitted */
  380. +    PACK(desc,"D",queue->size); /* ulSize */
  381. +    PACK(desc,"z",queue->file); /* pszComment */
  382. +  }
  383. +  if (uLevel == 2 || uLevel == 3) {
  384. +    PACK(desc,"W",50);        /* uPriority */
  385. +    PACK(desc,"z",queue->user); /* pszUserName */
  386. +    PACK(desc,"W",n+1);        /* uPosition */
  387. +    PACK(desc,"W",queue->status); /* fsStatus */
  388. +    PACK(desc,"D",queue->time); /* ulSubmitted */
  389. +    PACK(desc,"D",queue->size); /* ulSize */
  390. +    PACK(desc,"z","Samba");    /* pszComment */
  391. +    PACK(desc,"z",queue->file); /* pszDocument */
  392. +    if (uLevel == 3) {
  393. +      PACK(desc,"z","");    /* pszNotifyName */
  394. +      PACK(desc,"z","PM_Q_RAW"); /* pszDataType */
  395. +      PACK(desc,"z","");    /* pszParms */
  396. +      PACK(desc,"z","");    /* pszStatus */
  397. +      PACK(desc,"z",SERVICE(snum)); /* pszQueue */
  398. +      PACK(desc,"z","lpd");    /* pszQProcName */
  399. +      PACK(desc,"z","");    /* pszQProcParms */
  400. +      PACK(desc,"z","IBMNULL"); /* pszDriverName */
  401. +      PackDriverData(desc);    /* pDriverData */
  402. +      PACK(desc,"z","");    /* pszPrinterName */
  403. +    }
  404. +  }
  405. +}
  406. +
  407. +static void fill_printq_info(int cnum, int snum, int uLevel,
  408. +                  struct pack_desc* desc,
  409. +                  int count, print_queue_struct* queue,
  410. +                  print_status_struct* status)
  411. +{
  412. +  if (uLevel < 3)
  413. +    PACK(desc,"B13",SERVICE(snum));
  414. +  else
  415. +    PACK(desc,"z",Expand(cnum,snum,SERVICE(snum)));
  416. +  if (uLevel == 1 || uLevel == 2) {
  417. +    PACK(desc,"B",0);        /* alignment */
  418. +    PACK(desc,"W",5);        /* priority */
  419. +    PACK(desc,"W",0);        /* start time */
  420. +    PACK(desc,"W",0);        /* until time */
  421. +    PACK(desc,"z","");        /* pSepFile */
  422. +    PACK(desc,"z","lpd");    /* pPrProc */
  423. +    PACK(desc,"z",SERVICE(snum)); /* pDestinations */
  424. +    PACK(desc,"z",0);        /* pParms */
  425. +    if (snum < 0) {
  426. +      PACK(desc,"z","UNKNOWN PRINTER");
  427. +      PACK(desc,"W",LPSTAT_ERROR);
  428. +    }
  429. +    else if (!status->message[0]) {
  430. +      PACK(desc,"z",Expand(cnum,snum,lp_comment(snum)));
  431. +      PACK(desc,"W",LPSTAT_OK); /* status */
  432. +    }
  433. +    else {
  434. +      PACK(desc,"z",status->message);
  435. +      PACK(desc,"W",status->status); /* status */
  436. +    }
  437. +    PACK(desc,(uLevel == 1 ? "W" : "N"),count);
  438. +  }
  439. +  if (uLevel == 3 || uLevel == 4) {
  440. +    PACK(desc,"W",5);        /* uPriority */
  441. +    PACK(desc,"W",0);        /* uStarttime */
  442. +    PACK(desc,"W",0);        /* uUntiltime */
  443. +    PACK(desc,"W",5);        /* pad1 */
  444. +    PACK(desc,"z","");        /* pszSepFile */
  445. +    PACK(desc,"z","lpd");    /* pszPrProc */
  446. +    PACK(desc,"z","");        /* pszParms */
  447. +    if (!status->message[0]) {
  448. +      PACK(desc,"z",Expand(cnum,snum,lp_comment(snum))); /* pszComment */
  449. +      PACK(desc,"W",LPSTAT_OK); /* fsStatus */
  450. +    }
  451. +    else {
  452. +      PACK(desc,"z",status->message); /* pszComment */
  453. +      PACK(desc,"W",status->status); /* fsStatus */
  454. +    }
  455. +    PACK(desc,(uLevel == 3 ? "W" : "N"),count);    /* cJobs */
  456. +    PACK(desc,"z",SERVICE(snum)); /* pszPrinters */
  457. +    PACK(desc,"z","IBMNULL");    /* pszDriverName */
  458. +    PackDriverData(desc);    /* pDriverData */
  459. +  }
  460. +  if (uLevel == 2 || uLevel == 4) {
  461. +    int i;
  462. +    for (i=0;i<count;i++)
  463. +      fill_printjob_info(cnum,snum,uLevel == 2 ? 1 : 2,desc,&queue[i],i);
  464. +  }
  465. + 
  466. +  DEBUG(3,("fill_printq_info on <%s> gave %d entries\n",SERVICE(snum),count));
  467. +}
  468. +
  469.  static BOOL api_DosPrintQGetInfo(int cnum,char *param,char *data,
  470. -                  int mdrcnt,int mprcnt,
  471. -                  char **rdata,char **rparam,
  472. -                  int *rdata_len,int *rparam_len)
  473. +                 int mdrcnt,int mprcnt,
  474. +                 char **rdata,char **rparam,
  475. +                 int *rdata_len,int *rparam_len)
  476.  {
  477.    char *str1 = param+2;
  478.    char *str2 = skip_string(str1,1);
  479.    char *p = skip_string(str2,1);
  480.    char *QueueName = p;
  481.    int uLevel,cbBuf;
  482. -  int count=0;
  483. -  int i;
  484. -  print_queue_struct *queue=NULL;
  485. -  char *p2=NULL;
  486. +  int count;
  487.    int snum;
  488. +  char* str3;
  489. +  struct pack_desc desc;
  490. +  print_queue_struct *queue=NULL;
  491.    print_status_struct status;
  492. -
  493. -  status.message = NULL;
  494. -
  495. +  
  496. +  bzero(&status,sizeof(status));
  497. + 
  498.    p = skip_string(p,1);
  499.    uLevel = SVAL(p,0);
  500.    cbBuf = SVAL(p,2);
  501. -
  502. -  if ((p = strchr(QueueName,'%')))
  503. -    *p = 0;
  504. -
  505. +  str3 = p + 4;
  506. + 
  507. +  if ((p = strchr(QueueName,'%'))) *p = 0;
  508. + 
  509.    DEBUG(3,("PrintQueue uLevel=%d name=%s\n",uLevel,QueueName));
  510. -
  511. + 
  512.    /* check it's a supported varient */
  513. -  if (!
  514. -      ((uLevel==2 && strcsequal(str1,"zWrLh") && strcsequal(str2,"B13BWWWzzzzzWN")) ||
  515. -       (uLevel==1 && strcsequal(str1,"zWrLh") && strcsequal(str2,"B13BWWWzzzzzWW")) ||
  516. -       (uLevel==3 && strcsequal(str1,"zWrLh") && strcsequal(str2,"zWWWWzzzzWWzzl")) || 
  517. -       (uLevel==0 && strcsequal(str1,"zWrLh") && strcsequal(str2,"B13"))))
  518. -    return(False);
  519. -
  520. +  if (strcmp(str1,"zWrLh") != 0) return False;
  521. +  if (!check_printq_info(&desc,uLevel,str2,str3)) return False;
  522. + 
  523.    snum = lp_servicenumber(QueueName);
  524. -  if (snum < 0 && pcap_printername_ok(QueueName,NULL))
  525. -    {
  526. -      int pnum = lp_servicenumber(PRINTERS_NAME);
  527. -      if (pnum >= 0)
  528. -    {
  529. -      lp_add_printer(QueueName,pnum);
  530. -      snum = lp_servicenumber(QueueName);
  531. -    }
  532. +  if (snum < 0 && pcap_printername_ok(QueueName,NULL)) {
  533. +    int pnum = lp_servicenumber(PRINTERS_NAME);
  534. +    if (pnum >= 0) {
  535. +      lp_add_printer(QueueName,pnum);
  536. +      snum = lp_servicenumber(QueueName);
  537.      }
  538. -      
  539. +  }
  540. +  
  541. +  count = get_printqueue(snum,cnum,&queue,&status);
  542. +  if (mdrcnt > 0) *rdata = REALLOC(*rdata,mdrcnt);
  543. +  desc.base = *rdata;
  544. +  desc.buflen = mdrcnt;
  545. +  init_package(&desc,1,count);
  546. +  desc.subcount = count;
  547. +  fill_printq_info(cnum,snum,uLevel,&desc,count,queue,&status);
  548. +  *rdata_len = desc.usedlen;
  549. +  
  550. +  *rparam_len = 6;
  551. +  *rparam = REALLOC(*rparam,*rparam_len);
  552. +  SSVALS(*rparam,0,desc.errcode);
  553. +  SSVAL(*rparam,2,0);
  554. +  SSVAL(*rparam,4,desc.neededlen);
  555. +  
  556. +  DEBUG(4,("printqgetinfo: errorcode %d\n",desc.errcode));
  557.  
  558. -  /* go and get the actual queue entries */
  559. -  if (snum >= 0 && uLevel >= 1)
  560. -    count = get_printqueue(snum,cnum,&queue,&status);
  561. +  if (queue) free(queue);
  562. +  
  563. +  return(True);
  564. +}
  565.  
  566. -  /* don't return too many entries for the buffer */
  567. -  if (uLevel != 1)
  568. -    {
  569. -      count = MIN(count,(mdrcnt-(44+50))/94); 
  570. -      count = MAX(count,0);
  571. -    }
  572.  
  573. -  *rparam_len = 6;
  574. +/****************************************************************************
  575. +  view list of all print jobs on all queues
  576. +  ****************************************************************************/
  577. +static BOOL api_DosPrintQEnum(int cnum, char* param, char* data,
  578. +                   int mdrcnt, int mprcnt,
  579. +                   char **rdata, char** rparam,
  580. +                   int *rdata_len, int *rparam_len)
  581. +{
  582. +  char *param_format = param+2;
  583. +  char *output_format1 = skip_string(param_format,1);
  584. +  char *p = skip_string(output_format1,1);
  585. +  int uLevel = SVAL(p,0);
  586. +  char *output_format2 = p + 4;
  587. +  int services = lp_numservices();
  588. +  int i, n;
  589. +  struct pack_desc desc;
  590. +  print_queue_struct **queue = NULL;
  591. +  print_status_struct *status = NULL;
  592. +  int* subcntarr = NULL;
  593. +  int queuecnt, subcnt=0, succnt;
  594. + 
  595. +  DEBUG(3,("DosPrintQEnum uLevel=%d\n",uLevel));
  596. + 
  597. +  if (strcmp(param_format,"WrLeh") != 0) return False;
  598. +  if (!check_printq_info(&desc,uLevel,output_format1,output_format2))
  599. +    return False;
  600. +  queuecnt = 0;
  601. +  for (i = 0; i < services; i++)
  602. +    if (lp_print_ok(i) && lp_browseable(i))
  603. +      queuecnt++;
  604. +  if (uLevel > 0) {
  605. +    queue = (print_queue_struct**)malloc(queuecnt*sizeof(print_queue_struct*));
  606. +    memset(queue,0,queuecnt*sizeof(print_queue_struct*));
  607. +    status = (print_status_struct*)malloc(queuecnt*sizeof(print_status_struct));
  608. +    memset(status,0,queuecnt*sizeof(print_status_struct));
  609. +    subcntarr = (int*)malloc(queuecnt*sizeof(int));
  610. +    subcnt = 0;
  611. +    n = 0;
  612. +    for (i = 0; i < services; i++)
  613. +      if (lp_print_ok(i) && lp_browseable(i)) {
  614. +     subcntarr[n] = get_printqueue(i,cnum,&queue[n],&status[n]);
  615. +     subcnt += subcntarr[n];
  616. +     n++;
  617. +      }
  618. +  }
  619. +  if (mdrcnt > 0) *rdata = REALLOC(*rdata,mdrcnt);
  620. +  desc.base = *rdata;
  621. +  desc.buflen = mdrcnt;
  622. +  init_package(&desc,queuecnt,subcnt);
  623. +  n = 0;
  624. +  succnt = 0;
  625. +  for (i = 0; i < services; i++)
  626. +    if (lp_print_ok(i) && lp_browseable(i)) {
  627. +      fill_printq_info(cnum,i,uLevel,&desc,subcntarr[n],queue[n],&status[n]);
  628. +      n++;
  629. +      if (desc.errcode == NERR_Success) succnt = n;
  630. +    }
  631. +  if (subcntarr) free(subcntarr);
  632. + 
  633. +  *rdata_len = desc.usedlen;
  634. +  *rparam_len = 8;
  635.    *rparam = REALLOC(*rparam,*rparam_len);
  636. +  SSVALS(*rparam,0,desc.errcode);
  637. +  SSVAL(*rparam,2,0);
  638. +  SSVAL(*rparam,4,succnt);
  639. +  SSVAL(*rparam,6,queuecnt);
  640. +  
  641. +  for (i = 0; i < queuecnt; i++) {
  642. +    if (queue && queue[i]) free(queue[i]);
  643. +  }
  644.  
  645. -  switch (uLevel)
  646. -    {
  647. -    case 0:
  648. -      *rdata_len = 13; 
  649. -      *rdata = REALLOC(*rdata,*rdata_len);
  650. -      p2 = (*rdata) + (*rdata_len);
  651. -      SSVALS(*rparam,0,NERR_Success); /* 0x84b */
  652. -      SSVAL(*rparam,2,0); 
  653. -      SSVAL(*rparam,4,13); 
  654. -      break;
  655. +  if (queue) free(queue);
  656. +  if (status) free(status);
  657. +  
  658. +  return True;
  659. +}
  660.  
  661. -    case 1:
  662. -      *rdata_len = 13 + 1 + 30; 
  663. -      *rdata = REALLOC(*rdata,*rdata_len + 100);
  664. -
  665. -      p2 = (*rdata) + 44;
  666. -
  667. -      SSVAL(*rparam,0,NERR_Success);
  668. -      SSVAL(*rparam,2,0); /* converter word */
  669. -      SSVAL(*rparam,4,*rdata_len); /* length of rdata struct */
  670. -      break;
  671. -    case 2:
  672. -      *rdata_len = 13 + 1 + 30; 
  673. -      *rdata = REALLOC(*rdata,*rdata_len + 100 + count*(74+40));
  674. -
  675. -      p2 = (*rdata) + 44 + count*74; /* auxillery data (strings) 
  676. -                    will go here */
  677. -
  678. -      SSVAL(*rparam,0,NERR_Success);
  679. -      SSVAL(*rparam,2,0); /* converter word */
  680. -      SSVAL(*rparam,4,*rdata_len); /* length of rdata struct */
  681. -      break;
  682. -    case 3:
  683. -      *rdata_len = 0; 
  684. -      p2 = (*rdata) + (*rdata_len);
  685. -      SSVALS(*rparam,0,0x7c);
  686. -      SSVAL(*rparam,2,0x70); 
  687. -      SSVAL(*rparam,4,0); 
  688. -      break;
  689. -    }
  690. +/****************************************************************************
  691. +  get info about a share
  692. +  ****************************************************************************/
  693.  
  694. -  p = *rdata;
  695. +static int check_share_info(int uLevel, const char* id)
  696. +{
  697. +  switch( uLevel ) {
  698. +  case 0:
  699. +    if (strcmp(id,"B13") != 0) return False;
  700. +    break;
  701. +  case 1:
  702. +    if (strcmp(id,"B13BWz") != 0) return False;
  703. +    break;
  704. +  case 2:
  705. +    if (strcmp(id,"B13BWzWWWzB9B") != 0) return False;
  706. +    break;
  707. +  case 91:
  708. +    if (strcmp(id,"B13BWzWWWzB9BB9BWzWWzWW") != 0) return False;
  709. +    break;
  710. +  default: return False;
  711. +  }
  712. +  return True;
  713. +}
  714.  
  715. -  if (uLevel <= 2)
  716. +static int fill_share_info(int cnum, int snum, int uLevel,
  717. +                char** buf, int* buflen,
  718. +                char** stringbuf, int* stringspace, char* baseaddr)
  719. +{
  720. +  int struct_len;
  721. +  char* p;
  722. +  char* p2;
  723. +  int l2;
  724. +  int len;
  725. + 
  726. +  switch( uLevel ) {
  727. +  case 0: struct_len = 13; break;
  728. +  case 1: struct_len = 20; break;
  729. +  case 2: struct_len = 40; break;
  730. +  case 91: struct_len = 68; break;
  731. +  default: return -1;
  732. +  }
  733. +  
  734. + 
  735. +  if (!buf)
  736.      {
  737. -      StrnCpy(p,QueueName,13);
  738. -      p += 13;
  739. +      len = 0;
  740. +      if (uLevel > 0) len += StrlenExpanded(cnum,snum,lp_comment(snum));
  741. +      if (uLevel > 1) len += strlen(lp_pathname(snum)) + 1;
  742. +      if (buflen) *buflen = struct_len;
  743. +      if (stringspace) *stringspace = len;
  744. +      return struct_len + len;
  745.      }
  746. -
  747. -  if (uLevel == 2 || uLevel == 1)
  748. +  
  749. +  len = struct_len;
  750. +  p = *buf;
  751. +  if (*buflen < struct_len) return -1;
  752. +  if (stringbuf)
  753.      {
  754. -      p++; /* skip the pad byte */
  755. -      SSVAL(p,0,0); /* priority */
  756. -      SSVAL(p,2,0); /* start time */
  757. -      SSVAL(p,4,0); /* until time */
  758. -      SIVAL(p,6,0); /* pSepFile */
  759. -      SIVAL(p,10,0); /* pPrProc */
  760. -      SIVAL(p,14,0); /* pDestinations */
  761. -      SIVAL(p,18,0); /* pParms */
  762. -
  763. -      SIVAL(p,22,PTR_DIFF(p2,*rdata)); /* pComment */
  764. -      if (snum < 0) {
  765. -    strcpy(p2,"UNKNOWN PRINTER");
  766. -      } else {
  767. -    if (!status.message) {
  768. -      pstring comment;
  769. -      strcpy(comment,lp_comment(snum));
  770. -      string_sub(comment,"%S",lp_servicename(snum));
  771. -      standard_sub(cnum,comment);
  772. -      StrnCpy(p2,comment,40);
  773. -      SSVAL(p,26,LPSTAT_OK); /* status */
  774. -    } else {
  775. -      StrnCpy(p2,status.message,40);
  776. -      SSVAL(p,26,status.status); /* status */
  777. -    }
  778. -      }
  779. -
  780. -      p2 = skip_string(p2,1);
  781. -
  782. -      SSVAL(p,28,count); /* num jobs */
  783. -      p += 30;
  784. +      p2 = *stringbuf;
  785. +      l2 = *stringspace;
  786.      }
  787. -
  788. -  if (status.message) {
  789. -    free(status.message); 
  790. -    status.message = NULL;
  791. -  }
  792. -
  793. -  if (uLevel == 2)
  794. -  for (i=0;i<count;i++)
  795. +  else
  796.      {
  797. -      /* we encode the snum and job number in this way so we can extract
  798. -     then both for a print queue del operation */
  799. -      SSVAL(p,0,((snum%0xFF)<<8) | (queue[i].job%0xFF));
  800. -      StrnCpy(p+2,queue[i].user,21);
  801. -      StrnCpy(p+24,"",16); /* notify name */
  802. -      StrnCpy(p+40,"",10); /* data type */
  803. -      SIVAL(p,50,0); /* pParams */
  804. -      SSVAL(p,54,i); /* position */
  805. -      SSVAL(p,56,queue[i].status); /* status */
  806. -      SIVAL(p,58,0); /* pStatus string */
  807. -      SIVAL(p,62,queue[i].time); /* submit time */
  808. -      SIVAL(p,66,queue[i].size); /* job size */
  809. -
  810. -      SIVAL(p,70,PTR_DIFF(p2,*rdata));
  811. -      StrnCpy(p2,queue[i].file,39);
  812. -      p2 = skip_string(p2,1);      
  813. -
  814. -      p += 74;
  815. +      p2 = p + struct_len;
  816. +      l2 = *buflen - struct_len;
  817.      }
  818. -
  819. -  *rdata_len = PTR_DIFF(p2,*rdata);
  820. -
  821. -  if (queue) free(queue);
  822. +  if (!baseaddr) baseaddr = p;
  823. +  
  824. +  StrnCpy(p,lp_servicename(snum),13);
  825. +  
  826. +  if (uLevel > 0)
  827. +    {
  828. +      int type;
  829. +      CVAL(p,13) = 0;
  830. +      type = STYPE_DISKTREE;
  831. +      if (lp_print_ok(snum)) type = STYPE_PRINTQ;
  832. +      if (strequal("IPC$",lp_servicename(snum))) type = STYPE_IPC;
  833. +      SSVAL(p,14,type);        /* device type */
  834. +      SIVAL(p,16,PTR_DIFF(p2,baseaddr));
  835. +      len += CopyExpanded(cnum,snum,&p2,lp_comment(snum),&l2);
  836. +    }
  837. +  
  838. +  if (uLevel > 1)
  839. +    {
  840. +      SSVAL(p,20,ACCESS_READ|ACCESS_WRITE|ACCESS_CREATE); /* permissions */
  841. +      SSVAL(p,22,-1);        /* max uses */
  842. +      SSVAL(p,24,1); /* current uses */
  843. +      SIVAL(p,26,PTR_DIFF(p2,baseaddr)); /* local pathname */
  844. +      len += CopyAndAdvance(&p2,lp_pathname(snum),&l2);
  845. +      memset(p+30,0,SHPWLEN+2); /* passwd (reserved), pad field */
  846. +    }
  847. +  
  848. +  if (uLevel > 2)
  849. +    {
  850. +      memset(p+40,0,SHPWLEN+2);
  851. +      SSVAL(p,50,0);
  852. +      SIVAL(p,52,0);
  853. +      SSVAL(p,56,0);
  854. +      SSVAL(p,58,0);
  855. +      SIVAL(p,60,0);
  856. +      SSVAL(p,64,0);
  857. +      SSVAL(p,66,0);
  858. +    }
  859. +       
  860. +  if (stringbuf)
  861. +    {
  862. +      *buf = p + struct_len;
  863. +      *buflen -= struct_len;
  864. +      *stringbuf = p2;
  865. +      *stringspace = l2;
  866. +    }
  867. +  else
  868. +    {
  869. +      *buf = p2;
  870. +      *buflen -= len;
  871. +    }
  872. +  return len;
  873. +}
  874.  
  875. -  DEBUG(3,("DosPrintQGetInfo on <%s> gave %d entries\n",QueueName,count));
  876. +static BOOL api_RNetShareGetInfo(int cnum,char *param,char *data,
  877. +                 int mdrcnt,int mprcnt,
  878. +                 char **rdata,char **rparam,
  879. +                 int *rdata_len,int *rparam_len)
  880. +{
  881. +  char *str1 = param+2;
  882. +  char *str2 = skip_string(str1,1);
  883. +  char *netname = skip_string(str2,1);
  884. +  char *p = skip_string(netname,1);
  885. +  int uLevel = SVAL(p,0);
  886. +  int snum = find_service(netname);
  887. +  
  888. +  if (snum < 0) return False;
  889. +  
  890. +  /* check it's a supported varient */
  891. +  if (strcmp(str1,"zWrLh") != 0) return False;
  892. +  if (!check_share_info(uLevel,str2)) return False;
  893. + 
  894. +  *rdata = REALLOC(*rdata,mdrcnt);
  895. +  p = *rdata;
  896. +  *rdata_len = fill_share_info(cnum,snum,uLevel,&p,&mdrcnt,0,0,0);
  897. +  if (*rdata_len < 0) return False;
  898. + 
  899. +  *rparam_len = 6;
  900. +  *rparam = REALLOC(*rparam,*rparam_len);
  901. +  SSVAL(*rparam,0,NERR_Success);
  902. +  SSVAL(*rparam,2,0);        /* converter word */
  903. +  SSVAL(*rparam,4,*rdata_len);
  904. + 
  905.    return(True);
  906.  }
  907.  
  908. -
  909.  /****************************************************************************
  910. -view list of shares available
  911. -expect: WrLeh  B13BWz
  912. -
  913. -NOTE:  SEGV has been reported inside this routine. It needs to be investigated.
  914. -****************************************************************************/
  915. +  view list of shares available
  916. +  ****************************************************************************/
  917.  static BOOL api_RNetShareEnum(int cnum,char *param,char *data,
  918. -                  int mdrcnt,int mprcnt,
  919. -                  char **rdata,char **rparam,
  920. -                  int *rdata_len,int *rparam_len)
  921. +                    int mdrcnt,int mprcnt,
  922. +                    char **rdata,char **rparam,
  923. +                    int *rdata_len,int *rparam_len)
  924.  {
  925. -  char *p = skip_string(param+2,2);
  926. -  int level = SVAL(p,0);
  927. +  char *str1 = param+2;
  928. +  char *str2 = skip_string(str1,1);
  929. +  char *p = skip_string(str2,1);
  930. +  int uLevel = SVAL(p,0);
  931.    int buf_len = SVAL(p,2);
  932.    char *p2;
  933.    int count=lp_numservices();
  934.    int total=0,counted=0;
  935. -  int comment_len=0;
  936.    int i;
  937. -  BOOL squeezed = False;
  938. -
  939. +  int data_len, fixed_len, string_len;
  940. +  int f_len, s_len;
  941. + 
  942. +  if (strcmp(str1,"WrLeh") != 0) return False;
  943. +  if (!check_share_info(uLevel,str2)) return False;
  944. +  
  945. +  data_len = fixed_len = string_len = 0;
  946.    for (i=0;i<count;i++)
  947.      if (lp_browseable(i))
  948.        {
  949. -    pstring s;
  950. -    strcpy(s,lp_comment(i));
  951. -    string_sub(s,"%S",lp_servicename(i));
  952. -    standard_sub(cnum,s);
  953. -    total++;
  954. -    comment_len += strlen(s) + 1;
  955. +      total++;
  956. +     data_len += fill_share_info(cnum,i,uLevel,0,&f_len,0,&s_len,0);
  957. +     if (data_len <= buf_len)
  958. +       {
  959. +         counted++;
  960. +         fixed_len += f_len;
  961. +         string_len += s_len;
  962. +       }
  963.        }
  964. -
  965. -  *rparam_len = 8;
  966. -  *rparam = REALLOC(*rparam,*rparam_len);
  967. -
  968. -  *rdata_len = total*20 + comment_len;
  969. +  *rdata_len = fixed_len + string_len;
  970.    *rdata = REALLOC(*rdata,*rdata_len);
  971. -  bzero(*rdata,*rdata_len);
  972. -
  973. -  total = MIN(total,buf_len/25);
  974. -
  975. -  p2 = (*rdata) + total*20; /* auxillery data (strings) will go here */
  976. -
  977. +  memset(*rdata,0,*rdata_len);
  978. +  
  979. +  p2 = (*rdata) + fixed_len;    /* auxillery data (strings) will go here */
  980.    p = *rdata;
  981. -
  982. -  for (i=0;i<count && counted<total;i++)
  983. +  f_len = fixed_len;
  984. +  s_len = string_len;
  985. +  for (i = 0; i < count;i++)
  986.      if (lp_browseable(i))
  987. -      {
  988. -    int type = 0;
  989. -
  990. -    if (lp_print_ok(i)) type = 1;
  991. -    if (strequal("IPC$",lp_servicename(i))) type = 3;
  992. -
  993. -    StrnCpy(p,lp_servicename(i),12);
  994. -    CVAL(p,13) = 0; /* pad */
  995. -    SSVAL(p,14,type); /* device type */
  996. -    SIVAL(p,16,PTR_DIFF(p2,(*rdata)));
  997. -    strcpy(p2,lp_comment(i));
  998. -    string_sub(p2,"%S",lp_servicename(i));
  999. -    standard_sub(cnum,p2);
  1000. -
  1001. -    if (!squeezed &&
  1002. -        PTR_DIFF(skip_string(p2,1),*rdata) < (buf_len-2))
  1003. -      p2 = skip_string(p2,1);
  1004. -    else
  1005. -      squeezed = True;
  1006. -
  1007. -    p += 20;
  1008. -    counted++;
  1009. -      }
  1010. -
  1011. -
  1012. -  if (squeezed)
  1013. -    {
  1014. -      strcpy(p2,"-");
  1015. -      p2 += 2;
  1016. -    }
  1017. -
  1018. -  if (counted < total)
  1019. -    {
  1020. -      memmove((*rdata) + counted*20,(*rdata) + total*20,
  1021. -          PTR_DIFF(p2,(*rdata) + total*20)+2);
  1022. -      p2 -= (total-counted)*20;      
  1023. -    }
  1024. -
  1025. -  *rdata_len = PTR_DIFF(p2,(*rdata));
  1026. -
  1027. +      if (fill_share_info(cnum,i,uLevel,&p,&f_len,&p2,&s_len,*rdata) < 0)
  1028. +     break;
  1029. +  
  1030. +  *rparam_len = 8;
  1031. +  *rparam = REALLOC(*rparam,*rparam_len);
  1032.    SSVAL(*rparam,0,NERR_Success);
  1033. -  SSVAL(*rparam,2,(total-counted)*20); /* converter word */
  1034. +  SSVAL(*rparam,2,0);
  1035.    SSVAL(*rparam,4,counted);
  1036.    SSVAL(*rparam,6,total);
  1037. -
  1038. +  
  1039.    DEBUG(3,("RNetShareEnum gave %d entries of %d (%d %d %d %d)\n",
  1040. -       counted,total,level,
  1041. -       buf_len,*rdata_len,mdrcnt));
  1042. +        counted,total,uLevel,
  1043. +         buf_len,*rdata_len,mdrcnt));
  1044.    return(True);
  1045.  }
  1046.  
  1047.  
  1048.  
  1049.  /****************************************************************************
  1050. -get the time of day info
  1051. -****************************************************************************/
  1052. +  get the time of day info
  1053. +  ****************************************************************************/
  1054.  static BOOL api_NetRemoteTOD(int cnum,char *param,char *data,
  1055.                   int mdrcnt,int mprcnt,
  1056.                   char **rdata,char **rparam,
  1057. @@ -417,7 +876,7 @@
  1058.    *rdata = REALLOC(*rdata,*rdata_len);
  1059.  
  1060.    SSVAL(*rparam,0,NERR_Success);
  1061. -  SSVAL(*rparam,2,0); /* converter word */
  1062. +  SSVAL(*rparam,2,0);        /* converter word */
  1063.  
  1064.    p = *rdata;
  1065.  
  1066. @@ -428,16 +887,16 @@
  1067.      t = LocalTime(&unixdate,0);
  1068.  
  1069.      SIVAL(p,0,unixdate); 
  1070. -    SIVAL(p,4,0); /* msecs ? */
  1071. +    SIVAL(p,4,0);        /* msecs ? */
  1072.      CVAL(p,8) = t->tm_hour;
  1073.      CVAL(p,9) = t->tm_min;
  1074.      CVAL(p,10) = t->tm_sec;
  1075. -    CVAL(p,11) = 0; /* hundredths of seconds */
  1076. +    CVAL(p,11) = 0;        /* hundredths of seconds */
  1077.      SSVAL(p,12,TimeDiff(0)/60); /* timezone in minutes from GMT */
  1078. -    SSVAL(p,14,10000); /* timer interval in 0.0001 of sec */
  1079. +    SSVAL(p,14,10000);        /* timer interval in 0.0001 of sec */
  1080.      CVAL(p,16) = t->tm_mday;
  1081.      CVAL(p,17) = t->tm_mon + 1;
  1082. -    SSVAL(p,18,t->tm_year);
  1083. +    SSVAL(p,18,1900+t->tm_year);
  1084.      CVAL(p,20) = t->tm_wday;
  1085.    }
  1086.  
  1087. @@ -446,8 +905,8 @@
  1088.  }
  1089.  
  1090.  /****************************************************************************
  1091. -set the user password
  1092. -****************************************************************************/
  1093. +  set the user password
  1094. +  ****************************************************************************/
  1095.  static BOOL api_SetUserPassword(int cnum,char *param,char *data,
  1096.                  int mdrcnt,int mprcnt,
  1097.                  char **rdata,char **rparam,
  1098. @@ -468,7 +927,7 @@
  1099.    *rdata_len = 0;
  1100.  
  1101.    SSVAL(*rparam,0,NERR_Success);
  1102. -  SSVAL(*rparam,2,0); /* converter word */
  1103. +  SSVAL(*rparam,2,0);        /* converter word */
  1104.  
  1105.    DEBUG(3,("Set password for <%s>\n",user));
  1106.  
  1107. @@ -482,9 +941,9 @@
  1108.  }
  1109.  
  1110.  /****************************************************************************
  1111. -delete a print job
  1112. -Form: <W> <> 
  1113. -****************************************************************************/
  1114. +  delete a print job
  1115. +  Form: <W> <> 
  1116. +  ****************************************************************************/
  1117.  static BOOL api_RDosPrintJobDel(int cnum,char *param,char *data,
  1118.                  int mdrcnt,int mprcnt,
  1119.                  char **rdata,char **rparam,
  1120. @@ -497,6 +956,7 @@
  1121.                     by the print queue api */
  1122.    int snum = (SVAL(p,0)>>8);  
  1123.  
  1124. +  lpq_cache_reset = True;
  1125.  
  1126.    /* check it's a supported varient */
  1127.    if (!(strcsequal(str1,"W") && strcsequal(str2,"")))
  1128. @@ -508,7 +968,7 @@
  1129.    *rdata_len = 0;
  1130.  
  1131.    SSVAL(*rparam,0,NERR_Success);
  1132. -  SSVAL(*rparam,2,0); /* converter word */
  1133. +  SSVAL(*rparam,2,0);        /* converter word */
  1134.  
  1135.    if (snum >= 0)
  1136.      {
  1137. @@ -531,9 +991,59 @@
  1138.    return(True);
  1139.  }
  1140.  
  1141. +static BOOL api_WPrintQueuePurge(int cnum,char *param,char *data,
  1142. +                 int mdrcnt,int mprcnt,
  1143. +                 char **rdata,char **rparam,
  1144. +                 int *rdata_len,int *rparam_len)
  1145. +{
  1146. +  char *str1 = param+2;
  1147. +  char *str2 = skip_string(str1,1);
  1148. +  char *QueueName = skip_string(str2,1);
  1149. +  int snum;
  1150. +
  1151. +  lpq_cache_reset = True;
  1152. +
  1153. +  /* check it's a supported varient */
  1154. +  if (!(strcsequal(str1,"z") && strcsequal(str2,"")))
  1155. +    return(False);
  1156. +
  1157. +  *rparam_len = 4;
  1158. +  *rparam = REALLOC(*rparam,*rparam_len);
  1159. +
  1160. +  *rdata_len = 0;
  1161. +
  1162. +  SSVAL(*rparam,0,NERR_Success);
  1163. +  SSVAL(*rparam,2,0);        /* converter word */
  1164. +
  1165. +  snum = lp_servicenumber(QueueName);
  1166. +  if (snum < 0 && pcap_printername_ok(QueueName,NULL)) {
  1167. +    int pnum = lp_servicenumber(PRINTERS_NAME);
  1168. +    if (pnum >= 0) {
  1169. +      lp_add_printer(QueueName,pnum);
  1170. +      snum = lp_servicenumber(QueueName);
  1171. +    }
  1172. +  }
  1173. +
  1174. +  if (snum >= 0) {
  1175. +    print_queue_struct *queue=NULL;
  1176. +    int i;
  1177. +    int count = get_printqueue(snum,cnum,&queue,NULL);
  1178. +
  1179. +    for (i = 0; i < count; i++)
  1180. +      del_printqueue(cnum,snum,queue[i].job);
  1181. +
  1182. +    if (queue) free(queue);
  1183. +  }
  1184. +
  1185. +  DEBUG(3,("Print queue purge, queue=%s\n",QueueName));
  1186. +
  1187. +  return(True);
  1188. +}
  1189. +
  1190. +
  1191.  /****************************************************************************
  1192. -set the name of a print job (undocumented?)
  1193. -****************************************************************************/
  1194. +  set the name of a print job (undocumented?)
  1195. +  ****************************************************************************/
  1196.  static BOOL api_PrintJobInfo(int cnum,char *param,char *data,
  1197.                   int mdrcnt,int mprcnt,
  1198.                   char **rdata,char **rparam,
  1199. @@ -544,10 +1054,12 @@
  1200.    *rparam_len = 4;
  1201.    *rparam = REALLOC(*rparam,*rparam_len);
  1202.  
  1203. +  lpq_cache_reset = True;
  1204. +
  1205.    *rdata_len = 0;
  1206.  
  1207.    SSVAL(*rparam,0,NERR_Success);
  1208. -  SSVAL(*rparam,2,0); /* converter word */
  1209. +  SSVAL(*rparam,2,0);        /* converter word */
  1210.  
  1211.    /* now try to extract the name. As I don't really understand this
  1212.       API this is mostly guesswork.
  1213. @@ -586,8 +1098,18 @@
  1214.  
  1215.  
  1216.  /****************************************************************************
  1217. -get info about the server (no docs on this one - guesswork only)
  1218. -****************************************************************************/
  1219. +  get info about the server
  1220. +  ****************************************************************************/
  1221. +
  1222. +#define SV_TYPE_WORKSTATION    0x00000001
  1223. +#define SV_TYPE_SERVER        0x00000002
  1224. +#define SV_TYPE_SQLSERVER    0x00000004
  1225. +#define SV_TYPE_DOMAIN_CTRL    0x00000008
  1226. +#define SV_TYPE_DOMAIN_BAKCTRL    0x00000010
  1227. +#define SV_TYPE_TIME_SOURCE    0x00000020
  1228. +#define SV_TYPE_AFP        0x00000040
  1229. +#define SV_TYPE_NOVELL        0x00000080
  1230. +
  1231.  static BOOL api_RNetServerGetInfo(int cnum,char *param,char *data,
  1232.                    int mdrcnt,int mprcnt,
  1233.                    char **rdata,char **rparam,
  1234. @@ -596,71 +1118,82 @@
  1235.    char *str1 = param+2;
  1236.    char *str2 = skip_string(str1,1);
  1237.    char *p = skip_string(str2,1);
  1238. +  int uLevel = SVAL(p,0);
  1239.    char *p2;
  1240. -  pstring comment;
  1241. -  int level = SVAL(p,0);
  1242. -
  1243. -  DEBUG(4,("RNetServerGetInfo level %d\n",level));
  1244. -
  1245. -  *rparam_len = 6;
  1246. -  *rparam = REALLOC(*rparam,*rparam_len);
  1247. +  int struct_len;
  1248.  
  1249.    /* check it's a supported varient */
  1250. -  if (!(
  1251. -    (level==1 && strcsequal(str1,"WrLh") && strcsequal(str2,"B16BBDz")) ||
  1252. -    (level==50 && strcsequal(str1,"WrLh") && strcsequal(str2,"B16BBDzWWzzz"))
  1253. -    ))
  1254. -    return(False);
  1255. -
  1256. -  strcpy(comment,lp_serverstring());
  1257. -  standard_sub(cnum,comment);
  1258. +  if (strcmp(str1,"WrLh") != 0) return False;
  1259. +  switch( uLevel ) {
  1260. +  case 0:
  1261. +    if (strcmp(str2,"B16") != 0) return False;
  1262. +    struct_len = 16;
  1263. +    break;
  1264. +  case 1:
  1265. +    if (strcmp(str2,"B16BBDz") != 0) return False;
  1266. +    struct_len = 26;
  1267. +    break;
  1268. +  case 2:
  1269. +    if (strcmp(str2,"B16BBDzDDDWWzWWWWWWWBB21zWWWWWWWWWWWWWWWWWWWWWWz")
  1270. +    != 0) return False;
  1271. +    struct_len = 134;
  1272. +    break;
  1273. +  case 3:
  1274. +    if (strcmp(str2,"B16BBDzDDDWWzWWWWWWWBB21zWWWWWWWWWWWWWWWWWWWWWWzDWz")
  1275. +    != 0) return False;
  1276. +    struct_len = 144;
  1277. +    break;
  1278. +  case 20:
  1279. +    if (strcmp(str2,"DN") != 0) return False;
  1280. +    struct_len = 6;
  1281. +    break;
  1282. +  case 50:
  1283. +    if (strcmp(str2,"B16BBDzWWzzz") != 0) return False;
  1284. +    struct_len = 42;
  1285. +    break;
  1286. +  default: return False;
  1287. +  }
  1288.  
  1289.    *rdata_len = mdrcnt;
  1290.    *rdata = REALLOC(*rdata,*rdata_len);
  1291.  
  1292. -  SSVAL(*rparam,0,NERR_Success);
  1293. -  SSVAL(*rparam,2,0); /* converter word */
  1294. -
  1295.    p = *rdata;
  1296. -  p2 = p + 42;
  1297. -
  1298. -  StrnCpy(p,local_machine,16);
  1299. +  p2 = p + struct_len;
  1300. +  if (uLevel != 20) StrnCpy(p,local_machine,16);
  1301.    p += 16;
  1302. -  p += 2;
  1303. -  SIVAL(p,0,0xB03); /* unix server */
  1304. -  p += 4;
  1305. +  if (uLevel > 0)
  1306. +    {
  1307. +      pstring comment;
  1308. +      SCVAL(p,0,1);        /* version_major */
  1309. +      SCVAL(p,1,9);        /* version_minor */
  1310. +      SIVAL(p,2,SV_TYPE_WORKSTATION|SV_TYPE_SERVER|SV_TYPE_TIME_SOURCE
  1311. +        /*|SV_TYPE_DOMAIN_CTRL*/); /* type */
  1312. +      SIVAL(p,6,PTR_DIFF(p2,*rdata));
  1313. +      strcpy(comment,lp_serverstring());
  1314. +      standard_sub(cnum,comment);
  1315. +      StrnCpy(p2,comment,MAX(mdrcnt - struct_len,0));
  1316. +      p2 = skip_string(p2,1);
  1317. +    }
  1318. +  if (uLevel > 1)
  1319. +    {
  1320. +      return False;        /* not yet implemented */
  1321. +    }
  1322.  
  1323. -  SIVAL(p,0,PTR_DIFF(p2,*rdata)); p+=4;
  1324. -  strcpy(p2,comment);
  1325. -  p2 = skip_string(p2,1);      
  1326. -
  1327. -  if (strcsequal(str2,"B16BBDzWWzzz")) {
  1328. -    p += 4;
  1329. -
  1330. -    SIVAL(p,0,PTR_DIFF(p2,*rdata)); p+=4;
  1331. -    strcpy(p2,"str 1");
  1332. -    p2 = skip_string(p2,1);      
  1333. -
  1334. -    SIVAL(p,0,PTR_DIFF(p2,*rdata)); p+=4;
  1335. -    strcpy(p2,"str 2");
  1336. -    p2 = skip_string(p2,1);      
  1337. -    
  1338. -    SIVAL(p,0,PTR_DIFF(p2,*rdata)); p+=4;
  1339. -    strcpy(p2,"str 3");
  1340. -    p2 = skip_string(p2,1);      
  1341. -  }
  1342. -  
  1343.    *rdata_len = PTR_DIFF(p2,*rdata);
  1344.  
  1345. -  SSVAL(*rparam,4,*rdata_len); /* is this right? */
  1346. +  *rparam_len = 6;
  1347. +  *rparam = REALLOC(*rparam,*rparam_len);
  1348. +  SSVAL(*rparam,0,NERR_Success);
  1349. +  SSVAL(*rparam,2,0);        /* converter word */
  1350. +  SSVAL(*rparam,4,*rdata_len);
  1351.  
  1352.    return(True);
  1353.  }
  1354.  
  1355.  
  1356.  /****************************************************************************
  1357. -get info about the server
  1358. -****************************************************************************/
  1359. +  get info about the server
  1360. +  ****************************************************************************/
  1361.  static BOOL api_NetWkstaGetInfo(int cnum,char *param,char *data,
  1362.                  int mdrcnt,int mprcnt,
  1363.                  char **rdata,char **rparam,
  1364. @@ -686,7 +1219,7 @@
  1365.    *rdata = REALLOC(*rdata,*rdata_len);
  1366.  
  1367.    SSVAL(*rparam,0,NERR_Success);
  1368. -  SSVAL(*rparam,2,0); /* converter word */
  1369. +  SSVAL(*rparam,2,0);        /* converter word */
  1370.  
  1371.    p = *rdata;
  1372.    p2 = p + 22;
  1373. @@ -711,7 +1244,7 @@
  1374.    p += 2;
  1375.  
  1376.    SIVAL(p,0,PTR_DIFF(p2,*rdata));
  1377. -  strcpy(p2,lp_workgroup()); /* login domain */
  1378. +  strcpy(p2,lp_workgroup());    /* login domain */
  1379.    p2 = skip_string(p2,1);
  1380.    p += 4;
  1381.  
  1382. @@ -728,10 +1261,649 @@
  1383.  }
  1384.  
  1385.  
  1386. +/****************************************************************************
  1387. +  get info about a user
  1388. +  ****************************************************************************/
  1389. +
  1390. +#define USER_PRIV_GUEST 0
  1391. +#define USER_PRIV_USER 1
  1392. +#define USER_PRIV_ADMIN 2
  1393. +
  1394. +static BOOL api_RNetUserGetInfo(int cnum,char *param,char *data,
  1395. +                int mdrcnt,int mprcnt,
  1396. +                char **rdata,char **rparam,
  1397. +                int *rdata_len,int *rparam_len)
  1398. +{
  1399. +  char *str1 = param+2;
  1400. +  char *str2 = skip_string(str1,1);
  1401. +  char *UserName = skip_string(str2,1);
  1402. +  char *p = skip_string(UserName,1);
  1403. +  int uLevel = SVAL(p,0);
  1404. +  char *p2;
  1405. +
  1406. +  *rparam_len = 6;
  1407. +  *rparam = REALLOC(*rparam,*rparam_len);
  1408. +
  1409. +  /* check it's a supported varient */
  1410. +  if (strcmp(str1,"zWrLh") != 0) return False;
  1411. +  switch( uLevel ) {
  1412. +  case 0: p2 = "B21"; break;
  1413. +  case 1: p2 = "B21BB16DWzzWz"; break;
  1414. +  case 2: p2 = "B21BB16DWzzWzDzzzzDDDDWb21WWzWW"; break;
  1415. +  case 10: p2 = "B21Bzzz"; break;
  1416. +  case 11: p2 = "B21BzzzWDDzzDDWWzWzDWb21W"; break;
  1417. +  default: return False;
  1418. +  }
  1419. +  if (strcmp(p2,str2) != 0) return False;
  1420. +
  1421. +  *rdata_len = mdrcnt + 1024;
  1422. +  *rdata = REALLOC(*rdata,*rdata_len);
  1423. +
  1424. +  SSVAL(*rparam,0,NERR_Success);
  1425. +  SSVAL(*rparam,2,0);        /* converter word */
  1426. +
  1427. +  p = *rdata;
  1428. +  p2 = p + 86;
  1429. +
  1430. +  memset(p,0,21);
  1431. +  strcpy(p,UserName);
  1432. +  if (uLevel > 0) {
  1433. +    SCVAL(p,21,0);
  1434. +    *p2 = 0;
  1435. +    if (uLevel >= 10) {
  1436. +      SIVAL(p,22,PTR_DIFF(p2,*rdata)); /* comment */
  1437. +      SIVAL(p,26,PTR_DIFF(p2,*rdata)); /* user_comment */
  1438. +      SIVAL(p,30,PTR_DIFF(p2,*rdata)); /* full name */
  1439. +      p2++;
  1440. +    }
  1441. +    if (uLevel == 11) {
  1442. +      SSVAL(p,34,USER_PRIV_ADMIN); /* user privilege */
  1443. +      SIVAL(p,36,0);        /* auth flags */
  1444. +      SIVAL(p,40,0);        /* password age */
  1445. +      SIVAL(p,44,PTR_DIFF(p2,*rdata)); /* home dir */
  1446. +      strcpy(p2,"Y:\\GIGA\\C$\\PRJ\\USERS\\AD");
  1447. +      p2 = skip_string(p2,1);
  1448. +      SIVAL(p,48,PTR_DIFF(p2,*rdata)); /* parms */
  1449. +      strcpy(p2,"");
  1450. +      p2 = skip_string(p2,1);
  1451. +      SIVAL(p,52,0);        /* last logon */
  1452. +      SIVAL(p,56,0);        /* last logoff */
  1453. +      SSVAL(p,60,-1);        /* bad pw counts */
  1454. +      SSVAL(p,62,-1);        /* num logons */
  1455. +      SIVAL(p,64,PTR_DIFF(p2,*rdata)); /* logon server */
  1456. +      strcpy(p2,"\\\\GIGA");
  1457. +      p2 = skip_string(p2,1);
  1458. +      SSVAL(p,68,49);        /* country code */
  1459. +      SIVAL(p,70,0);        /* workstations */
  1460. +
  1461. +      SIVAL(p,74,-1L);        /* max storage */
  1462. +      SSVAL(p,78,168);        /* units per week */
  1463. +      SIVAL(p,80,PTR_DIFF(p2,*rdata)); /* logon hours */
  1464. +      memset(p2,-1,21);
  1465. +      p2 += 21;
  1466. +      SSVAL(p,84,860);        /* code page */
  1467. +    }
  1468. +    if (uLevel == 1 || uLevel == 2) {
  1469. +      memset(p+22,' ',16);    /* password */
  1470. +      SIVAL(p,38,-1);        /* password age */
  1471. +      SSVAL(p,42,USER_PRIV_ADMIN); /* user privilege */
  1472. +      SIVAL(p,44,PTR_DIFF(p2,*rdata)); /* home dir */
  1473. +      strcpy(p2,"Y:\\GIGA\\C$\\PRJ\\USERS\\AD");
  1474. +      p2 = skip_string(p2,1);
  1475. +      SIVAL(p,48,PTR_DIFF(p2,*rdata)); /* comment */
  1476. +      *p2++ = 0;
  1477. +      SSVAL(p,52,0);        /* flags */
  1478. +      SIVAL(p,54,0);        /* script_path */
  1479. +      if (uLevel == 2) {
  1480. +    SIVAL(p,60,0);        /* auth_flags */
  1481. +    SIVAL(p,64,PTR_DIFF(p2,*rdata)); /* full_name */
  1482. +    strcpy(p2,"<Full Name>");
  1483. +    p2 = skip_string(p2,1);
  1484. +    SIVAL(p,68,0);        /* urs_comment */
  1485. +    SIVAL(p,72,PTR_DIFF(p2,*rdata)); /* parms */
  1486. +    strcpy(p2,"");
  1487. +    p2 = skip_string(p2,1);
  1488. +    SIVAL(p,76,0);        /* workstations */
  1489. +    SIVAL(p,80,0);        /* last_logon */
  1490. +    SIVAL(p,84,0);        /* last_logoff */
  1491. +    SIVAL(p,88,-1);        /* acct_expires */
  1492. +    SIVAL(p,92,-1);        /* max_storage */
  1493. +    SSVAL(p,96,168);    /* units_per_week */
  1494. +    SIVAL(p,98,PTR_DIFF(p2,*rdata)); /* logon_hours */
  1495. +    memset(p2,-1,21);
  1496. +    p2 += 21;
  1497. +    SSVAL(p,102,-1);    /* bad_pw_count */
  1498. +    SSVAL(p,104,-1);    /* num_logons */
  1499. +    SIVAL(p,106,PTR_DIFF(p2,*rdata)); /* logon_server */
  1500. +    strcpy(p2,"\\\\GIGA");
  1501. +    p2 = skip_string(p2,1);
  1502. +    SSVAL(p,110,49);    /* country_code */
  1503. +    SSVAL(p,112,860);    /* code page */
  1504. +      }
  1505. +    }
  1506. +  }
  1507. +
  1508. +  *rdata_len = PTR_DIFF(p2,*rdata);
  1509. +
  1510. +  SSVAL(*rparam,4,*rdata_len);    /* is this right?? */
  1511. +
  1512. +  return(True);
  1513. +}
  1514. +
  1515. +static BOOL api_WWkstaUserLogon(int cnum,char *param,char *data,
  1516. +                int mdrcnt,int mprcnt,
  1517. +                char **rdata,char **rparam,
  1518. +                int *rdata_len,int *rparam_len)
  1519. +{
  1520. +  char *str1 = param+2;
  1521. +  char *str2 = skip_string(str1,1);
  1522. +  char *p = skip_string(str2,1);
  1523. +  int uLevel,cbBuf;
  1524. +  struct pack_desc desc;
  1525. +  char* name;
  1526. +
  1527. +  uLevel = SVAL(p,0);
  1528. +  cbBuf = SVAL(p,2);
  1529. +  name = p + 4;
  1530. +
  1531. +  DEBUG(3,("WWkstaUserLogon uLevel=%d name=%s\n",uLevel,name));
  1532. +
  1533. +  /* check it's a supported varient */
  1534. +  if (strcmp(str1,"OOWb54WrLh") != 0) return False;
  1535. +  if (uLevel != 1 || strcmp(str2,"WB21BWDWWDDDDDDDzzzD") != 0) return False;
  1536. +  if (mdrcnt > 0) *rdata = REALLOC(*rdata,mdrcnt);
  1537. +  desc.base = *rdata;
  1538. +  desc.buflen = mdrcnt;
  1539. +  desc.subformat = NULL;
  1540. +  desc.format = str2;
  1541. +  init_package(&desc,1,0);
  1542. +  PACK(&desc,"W",0);        /* code */
  1543. +  PACK(&desc,"B21",name);    /* eff. name */
  1544. +  PACK(&desc,"B",0);        /* pad */
  1545. +  PACK(&desc,"W",2);        /* priv */
  1546. +  PACK(&desc,"D",0);        /* auth flags */
  1547. +  PACK(&desc,"W",0);        /* num logons */
  1548. +  PACK(&desc,"W",0);        /* bad pw count */
  1549. +  PACK(&desc,"D",0);        /* last logon */
  1550. +  PACK(&desc,"D",0);        /* last logoff */
  1551. +  PACK(&desc,"D",-1);        /* logoff time */
  1552. +  PACK(&desc,"D",-1);        /* kickoff time */
  1553. +  PACK(&desc,"D",0);        /* password age */
  1554. +  PACK(&desc,"D",0);        /* password can change */
  1555. +  PACK(&desc,"D",-1);        /* password must change */
  1556. +  PACK(&desc,"z",local_machine);/* computer */
  1557. +  PACK(&desc,"z",lp_workgroup());/* domain */
  1558. +  PACK(&desc,"z",0);        /* script path */
  1559. +  PACK(&desc,"D",0);        /* reserved */
  1560. +  *rdata_len = desc.usedlen;
  1561. +
  1562. +  *rparam_len = 6;
  1563. +  *rparam = REALLOC(*rparam,*rparam_len);
  1564. +  SSVALS(*rparam,0,desc.errcode);
  1565. +  SSVAL(*rparam,2,0);
  1566. +  SSVAL(*rparam,4,desc.neededlen);
  1567. +
  1568. +  DEBUG(4,("WWkstaUserLogon: errorcode %d\n",desc.errcode));
  1569. +  return(True);
  1570. +}
  1571. +
  1572. +
  1573. +/****************************************************************************
  1574. +  api_WAccessGetUserPerms
  1575. +  ****************************************************************************/
  1576. +static BOOL api_WAccessGetUserPerms(int cnum,char *param,char *data,
  1577. +                    int mdrcnt,int mprcnt,
  1578. +                    char **rdata,char **rparam,
  1579. +                    int *rdata_len,int *rparam_len)
  1580. +{
  1581. +  char *str1 = param+2;
  1582. +  char *str2 = skip_string(str1,1);
  1583. +  char *user = skip_string(str2,1);
  1584. +  char *resource = skip_string(user,1);
  1585. +
  1586. +  DEBUG(3,("WAccessGetUserPerms user=%s resource=%s\n",user,resource));
  1587. +
  1588. +  /* check it's a supported varient */
  1589. +  if (strcmp(str1,"zzh") != 0) return False;
  1590. +  if (strcmp(str2,"") != 0) return False;
  1591. +
  1592. +  *rparam_len = 6;
  1593. +  *rparam = REALLOC(*rparam,*rparam_len);
  1594. +  SSVALS(*rparam,0,0);        /* errorcode */
  1595. +  SSVAL(*rparam,2,0);        /* converter word */
  1596. +  SSVAL(*rparam,4,0x7f);    /* permission flags */
  1597. +
  1598. +  return(True);
  1599. +}
  1600. +
  1601. +/****************************************************************************
  1602. +  api_WPrintJobEnumerate
  1603. +  ****************************************************************************/
  1604. +
  1605. +static int check_printjob_info(struct pack_desc* desc,
  1606. +                   int uLevel, const char* id)
  1607. +{
  1608. +  desc->subformat = NULL;
  1609. +  switch( uLevel ) {
  1610. +  case 0: desc->format = "W"; break;
  1611. +  case 1: desc->format = "WB21BB16B10zWWzDDz"; break;
  1612. +  case 2: desc->format = "WWzWWDDzz"; break;
  1613. +  case 3: desc->format = "WWzWWDDzzzzzzzzzzlz"; break;
  1614. +  default: return False;
  1615. +  }
  1616. +  if (strcmp(desc->format,id) != 0) return False;
  1617. +  return True;
  1618. +}
  1619. +
  1620. +static BOOL api_WPrintJobGetInfo(int cnum,char *param,char *data,
  1621. +                 int mdrcnt,int mprcnt,
  1622. +                 char **rdata,char **rparam,
  1623. +                 int *rdata_len,int *rparam_len)
  1624. +{
  1625. +  char *str1 = param+2;
  1626. +  char *str2 = skip_string(str1,1);
  1627. +  char *p = skip_string(str2,1);
  1628. +  int uJobId = SVAL(p,0);
  1629. +  int uLevel,cbBuf;
  1630. +  int count;
  1631. +  int i;
  1632. +  int snum;
  1633. +  int job;
  1634. +  struct pack_desc desc;
  1635. +  print_queue_struct *queue=NULL;
  1636. +  print_status_struct status;
  1637. +
  1638. +  uLevel = SVAL(p,2);
  1639. +  cbBuf = SVAL(p,4);
  1640. +
  1641. +  DEBUG(3,("WPrintJobGetInfo uLevel=%d uJobId=0x%X\n",uLevel,uJobId));
  1642. +
  1643. +  /* check it's a supported varient */
  1644. +  if (strcmp(str1,"WWrLh") != 0) return False;
  1645. +  if (!check_printjob_info(&desc,uLevel,str2)) return False;
  1646. +
  1647. +  snum = (unsigned int)uJobId >> 8; /*## valid serice number??*/
  1648. +  job = uJobId & 0xFF;
  1649. +
  1650. +  count = get_printqueue(snum,cnum,&queue,&status);
  1651. +  for (i = 0; i < count; i++) {
  1652. +    if ((queue[i].job % 0xFF) == job) break;
  1653. +  }
  1654. +  if (mdrcnt > 0) *rdata = REALLOC(*rdata,mdrcnt);
  1655. +  desc.base = *rdata;
  1656. +  desc.buflen = mdrcnt;
  1657. +  init_package(&desc,1,0);
  1658. +  if (i < count) {
  1659. +    fill_printjob_info(cnum,snum,uLevel,&desc,&queue[i],i);
  1660. +    *rdata_len = desc.usedlen;
  1661. +  }
  1662. +  else {
  1663. +    desc.errcode = NERR_JobNotFound;
  1664. +    *rdata_len = 0;
  1665. +  }
  1666. +
  1667. +  *rparam_len = 6;
  1668. +  *rparam = REALLOC(*rparam,*rparam_len);
  1669. +  SSVALS(*rparam,0,desc.errcode);
  1670. +  SSVAL(*rparam,2,0);
  1671. +  SSVAL(*rparam,4,desc.neededlen);
  1672. +
  1673. +  if (queue) free(queue);
  1674. +
  1675. +  DEBUG(4,("WPrintJobGetInfo: errorcode %d\n",desc.errcode));
  1676. +  return(True);
  1677. +}
  1678. +
  1679. +static BOOL api_WPrintJobEnumerate(int cnum,char *param,char *data,
  1680. +                   int mdrcnt,int mprcnt,
  1681. +                   char **rdata,char **rparam,
  1682. +                   int *rdata_len,int *rparam_len)
  1683. +{
  1684. +  char *str1 = param+2;
  1685. +  char *str2 = skip_string(str1,1);
  1686. +  char *p = skip_string(str2,1);
  1687. +  char* name = p;
  1688. +  int uLevel,cbBuf;
  1689. +  int count;
  1690. +  int i, succnt;
  1691. +  int snum;
  1692. +  struct pack_desc desc;
  1693. +  print_queue_struct *queue=NULL;
  1694. +  print_status_struct status;
  1695. +
  1696. +  p = skip_string(p,1);
  1697. +  uLevel = SVAL(p,0);
  1698. +  cbBuf = SVAL(p,2);
  1699. +
  1700. +  DEBUG(3,("WPrintJobEnumerate uLevel=%d name=%s\n",uLevel,name));
  1701. +
  1702. +  /* check it's a supported varient */
  1703. +  if (strcmp(str1,"zWrLeh") != 0) return False;
  1704. +  if (uLevel > 2) return False;    /* defined only for uLevel 0,1,2 */
  1705. +  if (!check_printjob_info(&desc,uLevel,str2)) return False;
  1706. +
  1707. +  snum = lp_servicenumber(name);
  1708. +  if (snum < 0 && pcap_printername_ok(name,NULL)) {
  1709. +    int pnum = lp_servicenumber(PRINTERS_NAME);
  1710. +    if (pnum >= 0) {
  1711. +      lp_add_printer(name,pnum);
  1712. +      snum = lp_servicenumber(name);
  1713. +    }
  1714. +  }
  1715. +
  1716. +  count = get_printqueue(snum,cnum,&queue,&status);
  1717. +  if (mdrcnt > 0) *rdata = REALLOC(*rdata,mdrcnt);
  1718. +  desc.base = *rdata;
  1719. +  desc.buflen = mdrcnt;
  1720. +  init_package(&desc,count,0);
  1721. +
  1722. +  succnt = 0;
  1723. +  for (i = 0; i < count; i++) {
  1724. +    fill_printjob_info(cnum,snum,uLevel,&desc,&queue[i],i);
  1725. +    if (desc.errcode == NERR_Success) succnt = i+1;
  1726. +  }
  1727. +  *rdata_len = desc.usedlen;
  1728. +
  1729. +  *rparam_len = 8;
  1730. +  *rparam = REALLOC(*rparam,*rparam_len);
  1731. +  SSVALS(*rparam,0,desc.errcode);
  1732. +  SSVAL(*rparam,2,0);
  1733. +  SSVAL(*rparam,4,succnt);
  1734. +  SSVAL(*rparam,6,count);
  1735. +
  1736. +  if (queue) free(queue);
  1737. +
  1738. +  DEBUG(4,("WPrintJobEnumerate: errorcode %d\n",desc.errcode));
  1739. +  return(True);
  1740. +}
  1741. +
  1742. +static int check_printdest_info(struct pack_desc* desc,
  1743. +                int uLevel, const char* id)
  1744. +{
  1745. +  desc->subformat = NULL;
  1746. +  switch( uLevel ) {
  1747. +  case 0: desc->format = "B9"; break;
  1748. +  case 1: desc->format = "B9B21WWzW"; break;
  1749. +  case 2: desc->format = "z"; break;
  1750. +  case 3: desc->format = "zzzWWzzzWW"; break;
  1751. +  default: return False;
  1752. +  }
  1753. +  if (strcmp(desc->format,id) != 0) return False;
  1754. +  return True;
  1755. +}
  1756. +
  1757. +static void fill_printdest_info(int cnum, int snum, int uLevel,
  1758. +                struct pack_desc* desc)
  1759. +{
  1760. +  char buf[100];
  1761. +  strcpy(buf,SERVICE(snum));
  1762. +  strupper(buf);
  1763. +  if (uLevel <= 1) {
  1764. +    PACK(desc,"B9",buf);    /* szName */
  1765. +    if (uLevel == 1) {
  1766. +      PACK(desc,"B21","");    /* szUserName */
  1767. +      PACK(desc,"W",0);        /* uJobId */
  1768. +      PACK(desc,"W",0);        /* fsStatus */
  1769. +      PACK(desc,"z","");    /* pszStatus */
  1770. +      PACK(desc,"W",0);        /* time */
  1771. +    }
  1772. +  }
  1773. +  if (uLevel == 2 || uLevel == 3) {
  1774. +    PACK(desc,"z",buf);        /* pszPrinterName */
  1775. +    if (uLevel == 3) {
  1776. +      PACK(desc,"z","");    /* pszUserName */
  1777. +      PACK(desc,"z",0);        /* pszLogAddr */
  1778. +      PACK(desc,"W",0);        /* uJobId */
  1779. +      PACK(desc,"W",0);        /* fsStatus */
  1780. +      PACK(desc,"z","");    /* pszStatus */
  1781. +      PACK(desc,"z","");    /* pszComment */
  1782. +      PACK(desc,"z","IBMNULL"); /* pszDrivers */
  1783. +      PACK(desc,"W",0);        /* time */
  1784. +      PACK(desc,"W",0);        /* pad1 */
  1785. +    }
  1786. +  }
  1787. +}
  1788. +
  1789. +static BOOL api_WPrintDestGetInfo(int cnum,char *param,char *data,
  1790. +                  int mdrcnt,int mprcnt,
  1791. +                  char **rdata,char **rparam,
  1792. +                  int *rdata_len,int *rparam_len)
  1793. +{
  1794. +  char *str1 = param+2;
  1795. +  char *str2 = skip_string(str1,1);
  1796. +  char *p = skip_string(str2,1);
  1797. +  char* PrinterName = p;
  1798. +  int uLevel,cbBuf;
  1799. +  struct pack_desc desc;
  1800. +  int snum;
  1801. +
  1802. +  p = skip_string(p,1);
  1803. +  uLevel = SVAL(p,0);
  1804. +  cbBuf = SVAL(p,2);
  1805. +
  1806. +  DEBUG(3,("WPrintDestGetInfo uLevel=%d PrinterName=%s\n",uLevel,PrinterName));
  1807. +
  1808. +  /* check it's a supported varient */
  1809. +  if (strcmp(str1,"zWrLh") != 0) return False;
  1810. +  if (!check_printdest_info(&desc,uLevel,str2)) return False;
  1811. +
  1812. +  snum = lp_servicenumber(PrinterName);
  1813. +  if (snum < 0 && pcap_printername_ok(PrinterName,NULL)) {
  1814. +    int pnum = lp_servicenumber(PRINTERS_NAME);
  1815. +    if (pnum >= 0) {
  1816. +      lp_add_printer(PrinterName,pnum);
  1817. +      snum = lp_servicenumber(PrinterName);
  1818. +    }
  1819. +  }
  1820. +
  1821. +  if (snum < 0) {
  1822. +    *rdata_len = 0;
  1823. +    desc.errcode = NERR_DestNotFound;
  1824. +    desc.neededlen = 0;
  1825. +  }
  1826. +  else {
  1827. +    if (mdrcnt > 0) *rdata = REALLOC(*rdata,mdrcnt);
  1828. +    desc.base = *rdata;
  1829. +    desc.buflen = mdrcnt;
  1830. +    init_package(&desc,1,0);
  1831. +    fill_printdest_info(cnum,snum,uLevel,&desc);
  1832. +    *rdata_len = desc.usedlen;
  1833. +  }
  1834. +
  1835. +  *rparam_len = 6;
  1836. +  *rparam = REALLOC(*rparam,*rparam_len);
  1837. +  SSVALS(*rparam,0,desc.errcode);
  1838. +  SSVAL(*rparam,2,0);
  1839. +  SSVAL(*rparam,4,desc.neededlen);
  1840. +
  1841. +  DEBUG(4,("WPrintDestGetInfo: errorcode %d\n",desc.errcode));
  1842. +  return(True);
  1843. +}
  1844. +
  1845. +static BOOL api_WPrintDestEnum(int cnum,char *param,char *data,
  1846. +                   int mdrcnt,int mprcnt,
  1847. +                   char **rdata,char **rparam,
  1848. +                   int *rdata_len,int *rparam_len)
  1849. +{
  1850. +  char *str1 = param+2;
  1851. +  char *str2 = skip_string(str1,1);
  1852. +  char *p = skip_string(str2,1);
  1853. +  int uLevel,cbBuf;
  1854. +  int queuecnt;
  1855. +  int i, n, succnt;
  1856. +  struct pack_desc desc;
  1857. +  int services = lp_numservices();
  1858. +
  1859. +  uLevel = SVAL(p,0);
  1860. +  cbBuf = SVAL(p,2);
  1861. +
  1862. +  DEBUG(3,("WPrintDestEnum uLevel=%d\n",uLevel));
  1863. +
  1864. +  /* check it's a supported varient */
  1865. +  if (strcmp(str1,"WrLeh") != 0) return False;
  1866. +  if (!check_printdest_info(&desc,uLevel,str2)) return False;
  1867. +
  1868. +  queuecnt = 0;
  1869. +  for (i = 0; i < services; i++)
  1870. +    if (lp_print_ok(i) && lp_browseable(i))
  1871. +      queuecnt++;
  1872. +
  1873. +  if (mdrcnt > 0) *rdata = REALLOC(*rdata,mdrcnt);
  1874. +  desc.base = *rdata;
  1875. +  desc.buflen = mdrcnt;
  1876. +  init_package(&desc,queuecnt,0);
  1877. +
  1878. +  succnt = 0;
  1879. +  n = 0;
  1880. +  for (i = 0; i < services; i++) {
  1881. +    if (lp_print_ok(i) && lp_browseable(i)) {
  1882. +      fill_printdest_info(cnum,i,uLevel,&desc);
  1883. +      n++;
  1884. +      if (desc.errcode == NERR_Success) succnt = n;
  1885. +    }
  1886. +  }
  1887. +  *rdata_len = desc.usedlen;
  1888. +
  1889. +  *rparam_len = 8;
  1890. +  *rparam = REALLOC(*rparam,*rparam_len);
  1891. +  SSVALS(*rparam,0,desc.errcode);
  1892. +  SSVAL(*rparam,2,0);
  1893. +  SSVAL(*rparam,4,succnt);
  1894. +  SSVAL(*rparam,6,queuecnt);
  1895. +
  1896. +  DEBUG(4,("WPrintDestEnumerate: errorcode %d\n",desc.errcode));
  1897. +  return(True);
  1898. +}
  1899. +
  1900. +static BOOL api_WPrintDriverEnum(int cnum,char *param,char *data,
  1901. +                 int mdrcnt,int mprcnt,
  1902. +                 char **rdata,char **rparam,
  1903. +                 int *rdata_len,int *rparam_len)
  1904. +{
  1905. +  char *str1 = param+2;
  1906. +  char *str2 = skip_string(str1,1);
  1907. +  char *p = skip_string(str2,1);
  1908. +  int uLevel,cbBuf;
  1909. +  int succnt;
  1910. +  struct pack_desc desc;
  1911. +
  1912. +  uLevel = SVAL(p,0);
  1913. +  cbBuf = SVAL(p,2);
  1914. +
  1915. +  DEBUG(3,("WPrintDriverEnum uLevel=%d\n",uLevel));
  1916. +
  1917. +  /* check it's a supported varient */
  1918. +  if (strcmp(str1,"WrLeh") != 0) return False;
  1919. +  if (uLevel != 0 || strcmp(str2,"B41") != 0) return False;
  1920. +
  1921. +  if (mdrcnt > 0) *rdata = REALLOC(*rdata,mdrcnt);
  1922. +  desc.base = *rdata;
  1923. +  desc.buflen = mdrcnt;
  1924. +  init_package(&desc,1,0);
  1925. +
  1926. +  PACK(&desc,"B41","IBMNULL");
  1927. +  succnt = (desc.errcode == NERR_Success ? 1 : 0);
  1928. +
  1929. +  *rdata_len = desc.usedlen;
  1930. +
  1931. +  *rparam_len = 8;
  1932. +  *rparam = REALLOC(*rparam,*rparam_len);
  1933. +  SSVALS(*rparam,0,desc.errcode);
  1934. +  SSVAL(*rparam,2,0);
  1935. +  SSVAL(*rparam,4,succnt);
  1936. +  SSVAL(*rparam,6,1);
  1937. +
  1938. +  DEBUG(4,("WPrintDriverEnum: errorcode %d\n",desc.errcode));
  1939. +  return(True);
  1940. +}
  1941. +
  1942. +static BOOL api_WPrintQProcEnum(int cnum,char *param,char *data,
  1943. +                int mdrcnt,int mprcnt,
  1944. +                char **rdata,char **rparam,
  1945. +                int *rdata_len,int *rparam_len)
  1946. +{
  1947. +  char *str1 = param+2;
  1948. +  char *str2 = skip_string(str1,1);
  1949. +  char *p = skip_string(str2,1);
  1950. +  int uLevel,cbBuf;
  1951. +  int succnt;
  1952. +  struct pack_desc desc;
  1953. +
  1954. +  uLevel = SVAL(p,0);
  1955. +  cbBuf = SVAL(p,2);
  1956. +
  1957. +  DEBUG(3,("WPrintQProcEnum uLevel=%d\n",uLevel));
  1958. +
  1959. +  /* check it's a supported varient */
  1960. +  if (strcmp(str1,"WrLeh") != 0) return False;
  1961. +  if (uLevel != 0 || strcmp(str2,"B13") != 0) return False;
  1962. +
  1963. +  if (mdrcnt > 0) *rdata = REALLOC(*rdata,mdrcnt);
  1964. +  desc.base = *rdata;
  1965. +  desc.buflen = mdrcnt;
  1966. +  init_package(&desc,1,0);
  1967. +
  1968. +  PACK(&desc,"B13","lpd");
  1969. +  succnt = (desc.errcode == NERR_Success ? 1 : 0);
  1970. +
  1971. +  *rdata_len = desc.usedlen;
  1972. +
  1973. +  *rparam_len = 8;
  1974. +  *rparam = REALLOC(*rparam,*rparam_len);
  1975. +  SSVALS(*rparam,0,desc.errcode);
  1976. +  SSVAL(*rparam,2,0);
  1977. +  SSVAL(*rparam,4,succnt);
  1978. +  SSVAL(*rparam,6,1);
  1979. +
  1980. +  DEBUG(4,("WPrintQProcEnum: errorcode %d\n",desc.errcode));
  1981. +  return(True);
  1982. +}
  1983. +
  1984. +static BOOL api_WPrintPortEnum(int cnum,char *param,char *data,
  1985. +                   int mdrcnt,int mprcnt,
  1986. +                   char **rdata,char **rparam,
  1987. +                   int *rdata_len,int *rparam_len)
  1988. +{
  1989. +  char *str1 = param+2;
  1990. +  char *str2 = skip_string(str1,1);
  1991. +  char *p = skip_string(str2,1);
  1992. +  int uLevel,cbBuf;
  1993. +  int succnt;
  1994. +  struct pack_desc desc;
  1995.  
  1996. +  uLevel = SVAL(p,0);
  1997. +  cbBuf = SVAL(p,2);
  1998. +
  1999. +  DEBUG(3,("WPrintPortEnum uLevel=%d\n",uLevel));
  2000. +
  2001. +  /* check it's a supported varient */
  2002. +  if (strcmp(str1,"WrLeh") != 0) return False;
  2003. +  if (uLevel != 0 || strcmp(str2,"B9") != 0) return False;
  2004. +
  2005. +  if (mdrcnt > 0) *rdata = REALLOC(*rdata,mdrcnt);
  2006. +  desc.base = *rdata;
  2007. +  desc.buflen = mdrcnt;
  2008. +  init_package(&desc,1,0);
  2009. +
  2010. +  PACK(&desc,"B13","lp0");
  2011. +  succnt = (desc.errcode == NERR_Success ? 1 : 0);
  2012. +
  2013. +  *rdata_len = desc.usedlen;
  2014. +
  2015. +  *rparam_len = 8;
  2016. +  *rparam = REALLOC(*rparam,*rparam_len);
  2017. +  SSVALS(*rparam,0,desc.errcode);
  2018. +  SSVAL(*rparam,2,0);
  2019. +  SSVAL(*rparam,4,succnt);
  2020. +  SSVAL(*rparam,6,1);
  2021. +
  2022. +  DEBUG(4,("WPrintPortEnum: errorcode %d\n",desc.errcode));
  2023. +  return(True);
  2024. +}
  2025. +
  2026.  /****************************************************************************
  2027. -the buffer was too small
  2028. -****************************************************************************/
  2029. +  the buffer was too small
  2030. +  ****************************************************************************/
  2031.  static BOOL api_TooSmall(int cnum,char *param,char *data,
  2032.               int mdrcnt,int mprcnt,
  2033.               char **rdata,char **rparam,
  2034. @@ -751,8 +1923,8 @@
  2035.  
  2036.  
  2037.  /****************************************************************************
  2038. -the request is not supported
  2039. -****************************************************************************/
  2040. +  the request is not supported
  2041. +  ****************************************************************************/
  2042.  static BOOL api_Unsupported(int cnum,char *param,char *data,
  2043.                  int mdrcnt,int mprcnt,
  2044.                  char **rdata,char **rparam,
  2045. @@ -764,7 +1936,7 @@
  2046.    *rdata_len = 0;
  2047.  
  2048.    SSVAL(*rparam,0,NERR_notsupported);
  2049. -  SSVAL(*rparam,2,0); /* converter word */
  2050. +  SSVAL(*rparam,2,0);        /* converter word */
  2051.  
  2052.    DEBUG(3,("Unsupported API command\n"));
  2053.  
  2054. @@ -781,20 +1953,33 @@
  2055.    BOOL (*fn)();
  2056.    int flags;
  2057.  } api_commands[] = {
  2058. -  {"DosPrintQGetInfo",70,api_DosPrintQGetInfo,0},
  2059. -  {"NetRemoteTOD",91,api_NetRemoteTOD,0},
  2060. -  {"SetUserPassword",115,api_SetUserPassword,0},
  2061. -  {"RNetShareEnum",0,api_RNetShareEnum,0},
  2062. -  {"RDosPrintJobDel",81,api_RDosPrintJobDel,0},
  2063. -  {"PrintJobInfo",147,api_PrintJobInfo,0},
  2064. -  {"RNetServerGetInfo",13,api_RNetServerGetInfo,0},
  2065. -  {"NetWkstaGetInfo",63,api_NetWkstaGetInfo,0},
  2066. -  {NULL,-1,api_Unsupported,0}};
  2067. +  {"RNetShareEnum",    0,    api_RNetShareEnum,0},
  2068. +  {"RNetShareGetInfo",    1,    api_RNetShareGetInfo,0},
  2069. +  {"RNetServerGetInfo",    13,    api_RNetServerGetInfo,0},
  2070. +  {"RNetUserGetInfo",    56,    api_RNetUserGetInfo,0},
  2071. +  {"NetWkstaGetInfo",    63,    api_NetWkstaGetInfo,0},
  2072. +  {"DosPrintQEnum",    69,    api_DosPrintQEnum,0},
  2073. +  {"DosPrintQGetInfo",    70,    api_DosPrintQGetInfo,0},
  2074. +  {"WPrintJobEnumerate",76,    api_WPrintJobEnumerate,0},
  2075. +  {"WPrintJobGetInfo",    77,    api_WPrintJobGetInfo,0},
  2076. +  {"RDosPrintJobDel",    81,    api_RDosPrintJobDel,0},
  2077. +  {"WPrintDestEnum",    84,    api_WPrintDestEnum,0},
  2078. +  {"WPrintDestGetInfo",    85,    api_WPrintDestGetInfo,0},
  2079. +  {"NetRemoteTOD",    91,    api_NetRemoteTOD,0},
  2080. +  {"WPrintQueuePurge",    103,    api_WPrintQueuePurge,0},
  2081. +  {"WAccessGetUserPerms",105,    api_WAccessGetUserPerms,0},
  2082. +  {"SetUserPassword",    115,    api_SetUserPassword,0},
  2083. +  {"WWkstaUserLogon",    132,    api_WWkstaUserLogon,0},
  2084. +  {"PrintJobInfo",    147,    api_PrintJobInfo,0},
  2085. +  {"WPrintDriverEnum",    205,    api_WPrintDriverEnum,0},
  2086. +  {"WPrintQProcEnum",    206,    api_WPrintQProcEnum,0},
  2087. +  {"WPrintPortEnum",    207,    api_WPrintPortEnum,0},
  2088. +  {NULL,        -1,    api_Unsupported,0}};
  2089.  
  2090.  
  2091.  /****************************************************************************
  2092. -handle remote api calls
  2093. -****************************************************************************/
  2094. +  handle remote api calls
  2095. +  ****************************************************************************/
  2096.  static int api_reply(int cnum,char *outbuf,char *data,char *params,
  2097.               int tdscnt,int tpscnt,int mdrcnt,int mprcnt)
  2098.  {
  2099. @@ -828,7 +2013,7 @@
  2100.        rparam_len > mprcnt)
  2101.      {
  2102.        reply = api_TooSmall(cnum,params,data,mdrcnt,mprcnt,
  2103. -            &rdata,&rparam,&rdata_len,&rparam_len);
  2104. +               &rdata,&rparam,&rdata_len,&rparam_len);
  2105.      }
  2106.          
  2107.  
  2108. @@ -851,8 +2036,8 @@
  2109.  }
  2110.  
  2111.  /****************************************************************************
  2112. -handle named pipe commands
  2113. -****************************************************************************/
  2114. +  handle named pipe commands
  2115. +  ****************************************************************************/
  2116.  static int named_pipe(int cnum,char *outbuf,char *name,
  2117.                uint16 *setup,char *data,char *params,
  2118.                int suwcnt,int tdscnt,int tpscnt,
  2119. @@ -871,7 +2056,7 @@
  2120.  
  2121.  /****************************************************************************
  2122.    reply to a SMBtrans
  2123. -****************************************************************************/
  2124. +  ****************************************************************************/
  2125.  int reply_trans(char *inbuf,char *outbuf)
  2126.  {
  2127.    fstring name;
  2128. @@ -937,7 +2122,7 @@
  2129.        /* Ensure this is still a trans packet (sanity check) */
  2130.        if(CVAL(inbuf, smb_com) != SMBtrans)
  2131.      {
  2132. -      DEBUG(0,("Invalid secondary trans2 packet\n"));
  2133. +      DEBUG(2,("Invalid secondary trans2 packet\n"));
  2134.        if (params) free(params);
  2135.        if (data) free(data);
  2136.        if (setup) free(setup);
  2137. diff -u -r --new-file last-version/source/nameserv.c samba-1.9.14alpha4/source/nameserv.c
  2138. --- last-version/source/nameserv.c    Sat Jul  1 01:10:56 1995
  2139. +++ samba-1.9.14alpha4/source/nameserv.c    Sun Jul  2 02:08:39 1995
  2140. @@ -908,7 +908,83 @@
  2141.    return;
  2142.  }
  2143.  
  2144. +/****************************************************************************
  2145. +reply to a name release
  2146. +****************************************************************************/
  2147. +static void reply_name_release(char *inbuf)
  2148. +{
  2149. +  pstring outbuf;
  2150. +  int rec_name_trn_id = RSVAL(inbuf,0);
  2151. +  char qname[100]="";
  2152. +  char *p = inbuf;
  2153. +  struct in_addr ip;
  2154. +  int n=0;
  2155. +  int name_type;
  2156. +  unsigned char nb_flags;
  2157. +  struct in_addr tmpip;
  2158. +  BOOL release_ok=False;
  2159. +  int reason=5;
  2160. +
  2161. +
  2162. +  bzero(outbuf,sizeof(outbuf));
  2163. +
  2164. +  name_type = name_extract(inbuf,12,qname);
  2165. +
  2166. +  p += 12;
  2167. +  p += name_len(p);
  2168. +  p += 4;
  2169. +  p += name_len(p);
  2170. +  p += 4;
  2171. +  nb_flags = CVAL(p,6);
  2172. +  p += 8;
  2173. +  putip((char *)&ip,p);
  2174. +
  2175. +  DEBUG(2,("Name release request for %s (%s) nb_flags=0x%x ntype=%d\n",
  2176. +    qname,inet_ntoa(ip),nb_flags,name_type));
  2177. +
  2178. +
  2179. +  n = find_name(qname,name_type,True);
  2180. +  if (n>=0 &&
  2181. +      !names[n].isgroup &&
  2182. +      memcmp(&names[n].ip,&ip,sizeof(ip))==0 &&
  2183. +      names[n].ttl != 0) {
  2184. +    release_ok = True;
  2185. +    names[n].valid = False;
  2186. +  }
  2187. +
  2188. +
  2189. +  /* Send a POSITIVE NAME RELEASE RESPONSE */
  2190. +  RSSVAL(outbuf,0,rec_name_trn_id);
  2191. +  CVAL(outbuf,2) = (1<<7) | (6<<3) | 4;
  2192. +  CVAL(outbuf,3) = release_ok?0:reason;
  2193. +  RSSVAL(outbuf,4,0);
  2194. +  RSSVAL(outbuf,6,1);
  2195. +  RSSVAL(outbuf,8,0);
  2196. +  RSSVAL(outbuf,10,0);  
  2197. +  p = outbuf+12;
  2198. +  strcpy(p,inbuf+12);
  2199. +  p += name_len(p);
  2200. +  RSSVAL(p,0,0x20);
  2201. +  RSSVAL(p,2,0x1);
  2202. +  RSIVAL(p,4,0); /* ttl */
  2203. +  RSSVAL(p,8,6);
  2204. +  RSSVAL(p,10,nb_flags);
  2205. +  p += 12;
  2206. +  putip(p,&ip);  
  2207. +  p += 4;
  2208. +
  2209. +  DEBUG(2,("Sending a %s name release response\n",release_ok?"positive":"negative"));
  2210. +  if (DEBUGLEVEL > 2)
  2211. +    show_nmb(outbuf);
  2212.  
  2213. +  tmpip = lastip;
  2214. +  num_good_sends++;
  2215. +  send_nmb(outbuf,PTR_DIFF(p,outbuf),&tmpip,lastport>0?lastport:137);
  2216. +
  2217. +  return;
  2218. +}
  2219. +
  2220. +
  2221.  /****************************************************************************
  2222.  reply to a name status query
  2223.  ****************************************************************************/
  2224. @@ -1163,6 +1239,12 @@
  2225.    if (opcode == 0 && qdcount==1)
  2226.      {
  2227.        reply_name_query(inbuf);
  2228. +      return;
  2229. +    }
  2230. +
  2231. +  if (!bcast && opcode == 6 && qdcount==1 && arcount==1)
  2232. +    {
  2233. +      reply_name_release(inbuf);
  2234.        return;
  2235.      }
  2236.  
  2237. diff -u -r --new-file last-version/source/printing.c samba-1.9.14alpha4/source/printing.c
  2238. --- last-version/source/printing.c    Fri Jun 30 17:32:52 1995
  2239. +++ samba-1.9.14alpha4/source/printing.c    Sat Jul  1 14:26:15 1995
  2240. @@ -25,9 +25,9 @@
  2241.  extern connection_struct Connections[];
  2242.  extern files_struct Files[];
  2243.  
  2244. +BOOL lpq_cache_reset = False;
  2245.  
  2246.  
  2247. -
  2248.  /****************************************************************************
  2249.  Build the print command in the supplied buffer. This means getting the
  2250.  print command for the service and inserting the printer name and the
  2251. @@ -101,6 +101,8 @@
  2252.    int cnum = Files[fnum].cnum;
  2253.    char *tempstr;
  2254.  
  2255. +  lpq_cache_reset = True;
  2256. +
  2257.    *syscmd = 0;
  2258.  
  2259.    if (Files[fnum].pos == -1) {
  2260. @@ -443,7 +445,7 @@
  2261.  
  2262.  
  2263.  char *stat0_strings[] = { "enabled", "online", "idle", NULL };
  2264. -char *stat1_strings[] = { "offline", "disabled", "down", NULL };
  2265. +char *stat1_strings[] = { "offline", "disabled", "down", "off", NULL };
  2266.  char *stat2_strings[] = { "jam", "paper", "error", "responding", "not accepting", "not running", NULL };
  2267.  
  2268.  /****************************************************************************
  2269. @@ -479,22 +481,19 @@
  2270.  
  2271.        for (i=0; stat0_strings[i]; i++)
  2272.          if (strstr(line,stat0_strings[i])) {
  2273. -      if (status->message) free(status->message);
  2274. -      status->message = strdup(line);
  2275. +      StrnCpy(status->message,line,sizeof(status->message)-1);
  2276.        status->status=LPSTAT_OK;
  2277.        return(ret);
  2278.          }
  2279.        for (i=0; stat1_strings[i]; i++)
  2280.          if (strstr(line,stat1_strings[i])) {
  2281. -      if (status->message) free(status->message);
  2282. -      status->message = strdup(line);
  2283. +      StrnCpy(status->message,line,sizeof(status->message)-1);
  2284.        status->status=LPSTAT_STOPPED;
  2285.        return(ret);
  2286.          }
  2287.        for (i=0; stat2_strings[i]; i++)
  2288.          if (strstr(line,stat2_strings[i])) {
  2289. -      if (status->message) free(status->message);
  2290. -      status->message = strdup(line);
  2291. +      StrnCpy(status->message,line,sizeof(status->message)-1);
  2292.        status->status=LPSTAT_ERROR;
  2293.        return(ret);
  2294.          }
  2295. @@ -543,7 +542,9 @@
  2296.  
  2297.    sprintf(outfile,"/tmp/lpq.%08x",str_checksum(syscmd));
  2298.  
  2299. -  if (cachetime && stat(outfile,&sbuf) == 0 && 
  2300. +  if (!lpq_cache_reset && 
  2301. +      cachetime && 
  2302. +      stat(outfile,&sbuf) == 0 && 
  2303.        (time(NULL) - sbuf.st_mtime)<cachetime) {
  2304.      DEBUG(3,("Using cached lpq output\n"));
  2305.      dorun = False;
  2306. @@ -553,7 +554,8 @@
  2307.      int fd = open(outfile,O_RDWR);
  2308.      if (fd >= 0) {
  2309.        flock(fd,LOCK_EX);
  2310. -      if (cachetime && fstat(fd,&sbuf) == 0 && 
  2311. +      if (!lpq_cache_reset &&
  2312. +      cachetime && fstat(fd,&sbuf) == 0 && 
  2313.        (time(NULL) - sbuf.st_mtime)<cachetime) {
  2314.      DEBUG(3,("Using cached lpq output\n"));
  2315.      dorun = False;
  2316. @@ -569,12 +571,14 @@
  2317.      DEBUG(3,("Running the command `%s' gave %d\n",syscmd,ret));
  2318.    }
  2319.  
  2320. +  lpq_cache_reset = False;
  2321. +
  2322.    f = fopen(outfile,"r");
  2323.    if (!f)
  2324.      return(0);
  2325.  
  2326.    if (status)
  2327. -    status->message = NULL;
  2328. +    strcpy(status->message,"");
  2329.        
  2330.    while (fgets(line,sizeof(pstring),f))
  2331.      {
  2332. diff -u -r --new-file last-version/source/server.c samba-1.9.14alpha4/source/server.c
  2333. --- last-version/source/server.c    Fri Jun 30 15:48:31 1995
  2334. +++ samba-1.9.14alpha4/source/server.c    Sat Jul  1 14:49:28 1995
  2335. @@ -1332,7 +1332,7 @@
  2336.  /****************************************************************************
  2337.    find a service entry
  2338.  ****************************************************************************/
  2339. -static int find_service(char *service)
  2340. +int find_service(char *service)
  2341.  {
  2342.     int iService;
  2343.  
  2344. @@ -3571,8 +3571,10 @@
  2345.        extern int keepalive;
  2346.  
  2347.        /* check for socket failure */
  2348. -      if (errno == EBADF)
  2349. +      if (errno == EBADF) {
  2350. +        DEBUG(2,("%s Bad file descriptor - exiting\n",timestring()));
  2351.          return;
  2352. +      }
  2353.  
  2354.        t = time(NULL);
  2355.  
  2356. @@ -3593,11 +3595,16 @@
  2357.          clean_share_files();
  2358.  
  2359.        /* automatic timeout if all connections are closed */      
  2360. -      if (num_connections_open==0 && counter >= IDLE_CLOSED_TIMEOUT)
  2361. +      if (num_connections_open==0 && counter >= IDLE_CLOSED_TIMEOUT) {
  2362. +        DEBUG(2,("%s Closing idle connection\n",timestring()));
  2363.          return;
  2364. +      }
  2365.  
  2366.        if (keepalive && (counter-last_keepalive)>keepalive) {
  2367. -        if (!send_keepalive(Client)) return;
  2368. +        if (!send_keepalive(Client)) {
  2369. +          DEBUG(2,("%s Keepalive failed - exiting\n",timestring()));
  2370. +          return;
  2371. +        }
  2372.          last_keepalive = counter;
  2373.        }
  2374.  
  2375. @@ -3614,8 +3621,10 @@
  2376.            allidle = False;
  2377.            }
  2378.  
  2379. -      if (allidle && num_connections_open>0)
  2380. +      if (allidle && num_connections_open>0) {
  2381. +        DEBUG(2,("%s Closing idle connection 2\n",timestring()));
  2382.          return;
  2383. +      }
  2384.      }
  2385.  
  2386.        msg_type = CVAL(InBuffer,0);
  2387. diff -u -r --new-file last-version/source/smb.h samba-1.9.14alpha4/source/smb.h
  2388. --- last-version/source/smb.h    Fri Jun 30 15:33:27 1995
  2389. +++ samba-1.9.14alpha4/source/smb.h    Sat Jul  1 14:01:04 1995
  2390. @@ -297,7 +297,7 @@
  2391.  
  2392.  typedef struct
  2393.  {
  2394. -  char *message;
  2395. +  fstring message;
  2396.    int status;
  2397.  }  print_status_struct;
  2398.  
  2399. @@ -548,6 +548,7 @@
  2400.  };
  2401.  
  2402.  /* and a few prototypes */
  2403. +int find_service(char *service);
  2404.  int TvalDiff(struct timeval *tvalold,struct timeval *tvalnew);
  2405.  int smb_offset(char *p,char *buf);
  2406.  void sync_file(int fnum);
  2407. diff -u -r --new-file last-version/source/trans2.c samba-1.9.14alpha4/source/trans2.c
  2408. --- last-version/source/trans2.c    Fri Jun 30 23:04:49 1995
  2409. +++ samba-1.9.14alpha4/source/trans2.c    Sat Jul  1 11:13:37 1995
  2410. @@ -385,21 +385,18 @@
  2411.        break;
  2412.  
  2413.      case 3:
  2414. -      if(requires_resume_key) {
  2415. -    SIVAL(p,0,reskey);
  2416. -    p += 4;
  2417. -      }
  2418. -      SIVAL(p,0,29+strlen(fname)+1);
  2419. +      SIVAL(p,0,reskey);
  2420.        put_dos_date2(p,4,cdate);
  2421.        put_dos_date2(p,8,adate);
  2422.        put_dos_date2(p,12,mdate);
  2423.        SIVAL(p,16,size);
  2424.        SIVAL(p,20,1024);
  2425.        SSVAL(p,24,mode);
  2426. -      CVAL(p,28) = strlen(fname);
  2427. -      strcpy(p + 29, fname);
  2428. -      name_ptr = p+29;
  2429. -      p += 29 + strlen(fname) + 1;
  2430. +      SIVAL(p,26,4);
  2431. +      CVAL(p,30) = strlen(fname);
  2432. +      strcpy(p+31, fname);
  2433. +      name_ptr = p+31;
  2434. +      p += 31 + strlen(fname) + 1;
  2435.        break;
  2436.  
  2437.      case 4:
  2438. diff -u -r --new-file last-version/source/util.c samba-1.9.14alpha4/source/util.c
  2439. --- last-version/source/util.c    Sat Jul  1 01:04:24 1995
  2440. +++ samba-1.9.14alpha4/source/util.c    Sat Jul  1 14:56:52 1995
  2441. @@ -3049,6 +3049,10 @@
  2442.    if(fstat(fd, &st)<0)
  2443.      return -1;
  2444.  
  2445. +#ifdef S_ISFIFO
  2446. +  if (S_ISFIFO(st.st_mode)) return 0;
  2447. +#endif
  2448. +
  2449.    if(st.st_size == len)
  2450.      return 0;
  2451.    if(st.st_size > len)
  2452. diff -u -r --new-file last-version/source/version.h samba-1.9.14alpha4/source/version.h
  2453. --- last-version/source/version.h    Sun Jul  2 02:10:34 1995
  2454. +++ samba-1.9.14alpha4/source/version.h    Sun Jul  2 02:17:52 1995
  2455. @@ -1 +1 @@
  2456. -#define VERSION "1.9.14alpha3"
  2457. +#define VERSION "1.9.14alpha4"
  2458.